code: def call_from_executor(self, callback, _max_postpone_until=None):
          
          assert _max_postpone_until is None or isinstance(_max_postpone_until, float)
          self._calls_from_executor.append((callback, _max_postpone_until))
  
          if self._schedule_pipe:
              try:
                  os.write(self._schedule_pipe[1], b'x')
              except (AttributeError, IndexError, OSError):
                  # Handle race condition. We're in a different thread.
                  # - `_schedule_pipe` could have become None in the meantime.
                  # - We catch `OSError` (actually BrokenPipeError), because the
                  #   main thread could have closed the pipe already.
                  pass
docs: Call this function in the main event loop.
          Similar to Twisted's ``callFromThread``.
  
          :param _max_postpone_until: `None` or `time.time` value. For interal
              use. If the eventloop is saturated, consider this task to be low
              priority and postpone maximum until this timestamp. (For instance,
              repaint is done using low priority.)