docs: def run(self):
          """ This defines the sequence of actions that are taken when the execution state is executed
  
          :return:
          """
          if self.is_root_state:
              self.execution_history.push_call_history_item(self, CallType.EXECUTE, None, self.input_data)
  
          logger.debug("Running {0}{1}".format(self, " (backwards)" if self.backward_execution else ""))
          if self.backward_execution:
              self.setup_backward_run()
          else:
              self.setup_run()
  
          try:
              outcome = self._execute(self.input_data, self.output_data, self.backward_execution)
              self.state_execution_status = StateExecutionStatus.WAIT_FOR_NEXT_STATE
  
              if self.backward_execution:
                  # outcome handling is not required as we are in backward mode and the execution order is fixed
                  result = self.finalize()
              else:
                  # check output data
                  self.check_output_data_type()
                  result = self.finalize(outcome)
  
              if self.is_root_state:
                  self.execution_history.push_return_history_item(self, CallType.EXECUTE, None, self.output_data)
              return result
          except Exception as e:
              exc_type, exc_value, exc_traceback = sys.exc_info()
              formatted_exc = traceback.format_exception(exc_type, exc_value, exc_traceback)
              truncated_exc = []
              for line in formatted_exc:
                  if os.path.join("rafcon", "core") not in line:
                      truncated_exc.append(line)
              logger.error("{0} had an internal error: {1}: {2}\n{3}".format(self, type(e).__name__, e,
                                                                             ''.join(truncated_exc)))
              # write error to the output_data of the state
              self.output_data["error"] = e
              self.state_execution_status = StateExecutionStatus.WAIT_FOR_NEXT_STATE
              return self.finalize(Outcome(-1, "aborted"))