class_docstr: Event loop for posix systems (Linux, Mac os X).
docstr: The input 'event loop'.
docstr_tok: ["The","input","'event","loop","'","."]
code: def run(self, stdin, callbacks):
      """
      The input 'event loop'.
      """
      assert isinstance(stdin, Input)
      assert isinstance(callbacks, EventLoopCallbacks)
      assert not self._running
  
      if self.closed:
          raise Exception("Event loop already closed.")
  
      self._running = True
      self._callbacks = callbacks
  
      inputstream = InputStream(callbacks.feed_key)
      current_timeout = [INPUT_TIMEOUT]  # Nonlocal
  
      # Create reader class.
      stdin_reader = PosixStdinReader(stdin.fileno())
  
      # Only attach SIGWINCH signal handler in main thread.
      # (It's not possible to attach signal handlers in other threads. In
      # that case we should rely on a the main thread to call this manually
      # instead.)
      if in_main_thread():
          ctx = call_on_sigwinch(self.received_winch)
      else:
          ctx = DummyContext()
  
      def read_from_stdin():
          "Read user input."
          # Feed input text.
          data = stdin_reader.read()
          inputstream.feed(data)
  
          # Set timeout again.
          current_timeout[0] = INPUT_TIMEOUT
  
          # Quit when the input stream was closed.
          if stdin_reader.closed:
              self.stop()
  
      self.add_reader(stdin, read_from_stdin)
      self.add_reader(self._schedule_pipe[0], None)
  
      with ctx:
          while self._running:
              # Call inputhook.
              if self._inputhook_context:
                  with TimeIt() as inputhook_timer:
  
                      def ready(wait):
                          "True when there is input ready. The inputhook should return control."
                          return (
                              self._ready_for_reading(
                                  current_timeout[0] if wait else 0
                              )
                              != []
                          )
  
                      self._inputhook_context.call_inputhook(ready)
                  inputhook_duration = inputhook_timer.duration
              else:
                  inputhook_duration = 0
  
              # Calculate remaining timeout. (The inputhook consumed some of the time.)
              if current_timeout[0] is None:
                  remaining_timeout = None
              else:
                  remaining_timeout = max(
                      0, current_timeout[0] - inputhook_duration
                  )
  
              # Wait until input is ready.
              fds = self._ready_for_reading(remaining_timeout)
  
              # When any of the FDs are ready. Call the appropriate callback.
              if fds:
                  # Create lists of high/low priority tasks. The main reason
                  # for this is to allow painting the UI to happen as soon as
                  # possible, but when there are many events happening, we
                  # don't want to call the UI renderer 1000x per second. If
                  # the eventloop is completely saturated with many CPU
                  # intensive tasks (like processing input/output), we say
                  # that drawing the UI can be postponed a little, to make
                  # CPU available. This will be a low priority task in that
                  # case.
                  tasks = []
                  low_priority_tasks = []
                  now = None  # Lazy load time. (Fewer system calls.)
  
                  for fd in fds:
                      # For the 'call_from_executor' fd, put each pending
                      # item on either the high or low priority queue.
                      if fd == self._schedule_pipe[0]:
                          for (
                              c,
                              max_postpone_until,
                          ) in self._calls_from_executor:
                              if max_postpone_until is None:
                                  # Execute now.
                                  tasks.append(c)
                              else:
                                  # Execute soon, if `max_postpone_until` is in the future.
                                  now = now or _now()
                                  if max_postpone_until < now:
                                      tasks.append(c)
                                  else:
                                      low_priority_tasks.append(
                                          (c, max_postpone_until)
                                      )
                          self._calls_from_executor = []
  
                          # Flush all the pipe content.
                          os.read(self._schedule_pipe[0], 1024)
                      else:
                          handler = self._read_fds.get(fd)
                          if handler:
                              tasks.append(handler)
  
                  # When there are high priority tasks, run all these.
                  # Schedule low priority tasks for the next iteration.
                  if tasks:
                      for t in tasks:
                          t()
  
                      # Postpone low priority tasks.
                      for t, max_postpone_until in low_priority_tasks:
                          self.call_from_executor(
                              t, _max_postpone_until=max_postpone_until
                          )
                  else:
                      # Currently there are only low priority tasks -> run them right now.
                      for t, _ in low_priority_tasks:
                          t()
  
              else:
                  # Flush all pending keys on a timeout. (This is most
                  # important to flush the vt100 'Escape' key early when
                  # nothing else follows.)
                  inputstream.flush()
  
                  # Fire input timeout event.
                  callbacks.input_timeout()
                  current_timeout[0] = None
  
      self.remove_reader(stdin)
      self.remove_reader(self._schedule_pipe[0])
  
      self._callbacks = None
  
imports: from __future__ import unicode_literals
  import fcntl
  import os
  import signal
  import threading
  import time
  from prompt_toolkit.terminal.vt100_input import InputStream
  from prompt_toolkit.utils import DummyContext, in_main_thread
  from prompt_toolkit.input import Input
  from .base import EventLoop, INPUT_TIMEOUT
  from .callbacks import EventLoopCallbacks
  from .inputhook import InputHookContext
  from .posix_utils import PosixStdinReader
  from .utils import TimeIt
  from .select import AutoSelector, Selector, fd_to_int
label_desc: Use image node_id 2 for calling the PosixEventLoop obj's underlying member method code with example usage: obj.run(stdin, callbacks) and returns: unknown