def runEventTransaction(self, player, line, match):
        """
        Take a player, input, and dictionary of parse results, resolve those
        parse results into implementations of appropriate interfaces in the
        game world, and execute the actual Action implementation (contained in
        the 'do' method) in an event transaction.

        This is the top level of action invocation.

        @param player: A L{Thing} representing the actor's body.

        @param line: A unicode string containing the original input

        @param match: A dictionary containing some parse results to pass
            through to this L{Action}'s C{do} method as keyword arguments.

        @raise eimaginary.AmbiguousArgument: if multiple valid targets are
            found for an argument.
        """
        def thunk():
            begin = time.time()
            try:
                actor = self.actorInterface(player)
                for (k, v) in match.items():
                    try:
                        objs = self.resolve(player, k, v)
                    except __HOLE__:
                        pass
                    else:
                        if len(objs) == 1:
                            match[k] = objs[0]
                        elif len(objs) == 0:
                            self.cantFind(player, actor, k, v)
                        else:
                            raise eimaginary.AmbiguousArgument(self, k, v, objs)
                return self.do(actor, line, **match)
            finally:
                end = time.time()
                log.msg(interface=iaxiom.IStatEvent,
                        stat_actionDuration=end - begin,
                        stat_actionExecuted=1)
        events.runEventTransaction(player.store, thunk)
dataset/ETHPy150Open twisted/imaginary/imaginary/action.py/Action.runEventTransaction