code: def eat(self, argv=None):
          
          # The setup phase, here KeyboardInterrupt is a silent sign to exit the
          # application. Any error that happens here will result in a raw
          # backtrace being printed to the user.
          try:
              self.context.argv = argv
              self._added()
              self._build_early_parser()
              self._preparse()
              self._early_init()
              self._build_parser()
              self._parse()
              self._late_init()
          except KeyboardInterrupt:
              self._shutdown()
              return
          # The execution phase. Here we differentiate SystemExit from all other
          # exceptions. SystemExit is just re-raised as that's what any piece of
          # code can raise to ask to exit the currently running application.  All
          # other exceptions are recorded in the context and the failure-path of
          # the dispatch is followed. In other case, when there are no
          # exceptions, the success-path is followed. In both cases, ingredients
          # are shut down.
          try:
              return self._dispatch()
          except SystemExit:
              raise
          except BaseException:
              (self.context.exc_type, self.context.exc_value,
               self.context.traceback) = sys.exc_info()
              self._dispatch_failed()
          else:
              self._dispatch_succeeded()
          finally:
              self._shutdown()
docs: Eat the guacamole.
  
          :param argv:
              Command line arguments or None. None means that sys.argv is used
          :return:
              Whatever is returned by the first ingredient that agrees to perform
              the command dispatch.
  
          The eat method is called to run the application, as if it was invoked
          from command line directly.