code: def call_async(self, fn, *args, **kwargs):
          
          LOG.debug('%r.call_async(): %r', self, CallSpec(fn, args, kwargs))
          return self.context.send_async(self.make_msg(fn, *args, **kwargs))
docs: Arrange for `fn(*args, **kwargs)` to be invoked on the context's main
          thread.
  
          :param fn:
              A free function in module scope or a class method of a class
              directly reachable from module scope:
  
              .. code-block:: python
  
                  # mymodule.py
  
                  def my_func():
                      '''A free function reachable as mymodule.my_func'''
  
                  class MyClass:
                      @classmethod
                      def my_classmethod(cls):
                          '''Reachable as mymodule.MyClass.my_classmethod'''
  
                      def my_instancemethod(self):
                          '''Unreachable: requires a class instance!'''
  
                      class MyEmbeddedClass:
                          @classmethod
                          def my_classmethod(cls):
                              '''Not directly reachable from module scope!'''
  
          :param tuple args:
              Function arguments, if any. See :ref:`serialization-rules` for
              permitted types.
          :param dict kwargs:
              Function keyword arguments, if any. See :ref:`serialization-rules`
              for permitted types.
          :returns:
              :class:`mitogen.core.Receiver` configured to receive the result of
              the invocation:
  
              .. code-block:: python
  
                  recv = context.call_async(os.check_output, 'ls /tmp/')
                  try:
                      # Prints output once it is received.
                      msg = recv.get()
                      print(msg.unpickle())
                  except mitogen.core.CallError, e:
                      print('Call failed:', str(e))
  
              Asynchronous calls may be dispatched in parallel to multiple
              contexts and consumed as they complete using
              :class:`mitogen.select.Select`.