# 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."""
__file__ = '/Users/Shared/src/ide/build-files/build-temp/runtimes-release/__os__/osx/runtime-python3.8/lib/Python.framework/Versions/Current/lib/python3.8/lib-dynload/_xxsubinterpreters.cpython-38-darwin.so'
__loader__ = None
__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_recv(cid):
  """ channel_recv(cid) -> obj
  
  Return a new object from the data at the from of the channel's queue. """
  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