# 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 ChannelClosedError(ChannelError):

  pass

class ChannelEmptyError(ChannelError):

  pass

class ChannelError(RuntimeError):

  pass

class ChannelID(object):
  """ A channel ID identifies a channel and may be used as an int. """

  end = property(None, None, None,
                 """ 'send', 'recv', or 'both' """
                 )

  recv = property(None, None, None,
                  """ the 'recv' end of the channel """
                  )

  send = property(None, None, None,
                  """ the 'send' end of the channel """
                  )


  pass

class ChannelNotEmptyError(ChannelError):

  pass

class ChannelNotFoundError(ChannelError):

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

def _channel_id():
  pass

def close():
  """ channel_close(cid, *, send=None, recv=None, force=False)
  
  Close the channel for all interpreters.
  
  If the channel is empty then the keyword args are ignored and both
  ends are immediately closed.  Otherwise, if 'force' is True then
  all queued items are released and both ends are immediately
  closed.
  
  If the channel is not empty *and* 'force' is False then following
  happens:
  
   * recv is True (regardless of send):
     - raise ChannelNotEmptyError
   * recv is None and send is None:
     - raise ChannelNotEmptyError
   * send is True and recv is not True:
     - fully close the 'send' end
     - close the 'recv' end to interpreters not already receiving
     - fully close it once empty
  
  Closing an already closed channel results in a ChannelClosedError.
  
  Once the channel's ID has no more ref counts in any interpreter
  the channel will be destroyed. """
  pass

def create():
  """ channel_create() -> cid
  
  Create a new cross-interpreter channel and return a unique generated ID. """
  return None

def destroy(cid):
  """ channel_destroy(cid)
  
  Close and finalize the channel.  Afterward attempts to use the channel
  will behave as though it never existed. """
  pass

def list_all():
  """ channel_list_all() -> [cid]
  
  Return the list of all IDs for active channels. """
  return [None]

def list_interpreters(cid, arg0, send):
  """ channel_list_interpreters(cid, *, send) -> [id]
  
  Return the list of all interpreter IDs associated with an end of the channel.
  
  The 'send' argument should be a boolean indicating whether to use the send or
  receive end. """
  return [None]

def recv(cid, default=None):
  """ channel_recv(cid, [default]) -> obj
  
  Return a new object from the data at the front of the channel's queue.
  
  If there is nothing to receive then raise ChannelEmptyError, unless
  a default value is provided.  In that case return it. """
  return None

def release():
  """ channel_release(cid, *, send=None, recv=None, force=True)
  
  Close the channel for the current interpreter.  'send' and 'recv'
  (bool) may be used to indicate the ends to close.  By default both
  ends are closed.  Closing an already closed end is a noop. """
  pass

def send(cid, obj):
  """ channel_send(cid, obj)
  
  Add the object's data to the channel's queue. """
  pass