# 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

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

  pass

class RunFailedError(RuntimeError):

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

def _channel_id():
  pass

def channel_close(arg0):
  """ 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 channel_create():
  """ channel_create() -> cid
  
  Create a new cross-interpreter channel and return a unique generated ID. """
  return None

def channel_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 channel_list_all():
  """ channel_list_all() -> [cid]
  
  Return the list of all IDs for active channels. """
  return [None]

def channel_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 channel_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 channel_release(bool):
  """ 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 channel_send(cid, obj):
  """ channel_send(cid, obj)
  
  Add the object's data to the channel's queue. """
  pass

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

def destroy(id):
  """ destroy(id)
  
  Destroy the identified interpreter.
  
  Attempting to destroy the current interpreter results in a RuntimeError.
  So does an unrecognized ID. """
  pass

def get_current():
  """ get_current() -> ID
  
  Return the ID of current interpreter. """
  return None

def get_main():
  """ get_main() -> ID
  
  Return the ID of main interpreter. """
  return None

def is_running(id):
  """ is_running(id) -> bool
  
  Return whether or not the identified interpreter is running. """
  return None

def is_shareable(obj):
  """ is_shareable(obj) -> bool
  
  Return True if the object's data may be shared between interpreters and
  False otherwise. """
  return None

def list_all():
  """ list_all() -> [ID]
  
  Return a list containing the ID of every existing interpreter. """
  return [None]

def run_string(id, script, shared):
  """ run_string(id, script, shared)
  
  Execute the provided string in the identified interpreter.
  
  See PyRun_SimpleStrings. """
  pass