Used by the Pipeline evaluator to execute this Pipeline.
324514
def _run_internal(self,
                    context,
                    pipeline_key,
                    root_pipeline_key,
                    caller_output):
    """"""
    self._set_values_internal(
        context, pipeline_key, root_pipeline_key, caller_output,
        _PipelineRecord.RUN)
    logging.debug('Running %s(*%s, **%s)#%s',
                  self._class_path, _short_repr(self.args),
                  _short_repr(self.kwargs), self._pipeline_key.name())
    return self.run(*self.args, **self.kwargs)
749781
private void reconstructExecutionPipelines() {

		final Iterator<ExecutionStage> it = this.stages.iterator();
		while (it.hasNext()) {

			it.next().reconstructExecutionPipelines();
		}
	}
985751
public void run() {
    // Input step
    Database db = inputStep.getDatabase();
    hier = db.getHierarchy();

    // Algorithms - Data Mining Step
    algorithmStep.runAlgorithms(db);

    // TODO: this could be nicer
    hier.add(db, new SettingsResult(settings));

    // Evaluation
    evaluationStep.runEvaluators(hier, db);

    // Output / Visualization
    outputStep.runResultHandlers(hier, db);
  }
912684
def do_execute(self):
        
        data = self.input.payload
        cls = self.resolve_option("setup")
        if isinstance(cls, Classifier):
            cls = Classifier.make_copy(cls)
            evl = Evaluation(data)
            evl.discard_predictions = bool(self.resolve_option("discard_predictions"))
            evl.crossvalidate_model(
                cls,
                data,
                int(self.resolve_option("folds")),
                Random(int(self.resolve_option("seed"))),
                self.resolve_option("output"))
            self._output.append(Token(evl))
        elif isinstance(cls, Clusterer):
            cls = Clusterer.make_copy(cls)
            evl = ClusterEvaluation()
            llh = evl.crossvalidate_model(
                cls,
                data,
                int(self.resolve_option("folds")),
                Random(int(self.resolve_option("seed"))))
            self._output.append(Token(llh))
        else:
            return "Unhandled class: " + classes.get_classname(cls)
        return None
1239491
def _execute_example(self):
        ""
        test_benchmark = Benchmark()
        try:
            with Registry(), test_benchmark:
                if accepts_arg(self.example.testfn):
                    self.example.testfn(self.context)
                else:
                    self.context.inject_into_self(self.example.testfn)
                    self.example.testfn()
                self.num_successes += 1
        except KeyboardInterrupt:
            # bubble interrupt for canceling spec execution
            raise
        except:
            raise
            self.num_failures += 1
        finally:
            self.example.user_time = test_benchmark.total_time
1006778
def execute(self, *args, **kwargs):
        
        args = self.parser.parse_args(*args, **kwargs)
        self.process(args)
1244932
@Override
    protected void doExecute() throws Exception {
        final CommandHandler commandHandler = new CommandHandlerImpl(this.getLog());

        checkStageDirectoryExistence();

        checkRuntimeExistence(commandHandler);

        runFunctions(commandHandler);
    }
1006759
public void run () throws MojoExecutionException, MojoFailureException
  {
    ESuccess exitCode;
    try
    {
      if (getLog ().isDebugEnabled ())
      {
        getLog ().debug ("Running " + getToolName () + ": " + this);
      }
      exitCode = execute ();
    }
    catch (final Exception e)
    {
      throw new MojoExecutionException ("Failed to execute " + getToolName (), e);
    }
    if (exitCode.isFailure ())
    {
      throw new MojoFailureException (getToolName () + " reported failure: " + this);
    }
  }
493588
public void execute()
        throws MojoExecutionException, MojoFailureException
    {
        if ( isSkipping() )
        {
            getLog().debug( "Skipping execution, as demanded by user." );
            return;
        }
        if ( transformationSets == null || transformationSets.length == 0 )
        {
            throw new MojoFailureException( "No TransformationSets configured." );
        }
        checkCatalogHandling();

        Object oldProxySettings = activateProxy();
        try
        {
            Resolver resolver = getResolver();
            for ( int i = 0; i < transformationSets.length; i++ )
            {
                TransformationSet transformationSet = transformationSets[i];
                resolver.setXincludeAware( transformationSet.isXincludeAware() );
                resolver.setValidating( transformationSet.isValidating() );
                transform( resolver, transformationSet );
            }
        }
        finally
        {
            passivateProxy( oldProxySettings );
        }
    }
121662
public void execute(InterpreterSelector interpreterSelector)
    {
        AbstractSpecification spec = new FilteredSpecification( start );

        while (spec.hasMoreExamples() && canContinue( stats ))
        {
            Interpreter interpreter = interpreterSelector.selectInterpreter( spec.peek() );
            interpreter.interpret( spec );
        }
    }
974682
@Override
    protected void searchStep() {
        // execute pipeline
        pipeline.stream().forEachOrdered(l -> {
            // attach listener
            l.addSearchListener(pipelineListener);
            // set initial solution (copy!)
            l.setCurrentSolution(Solution.checkedCopy(getCurrentSolution()));
            // run local search
            l.start();
            // get best solution found by search l
            SolutionType bestSol = l.getBestSolution();
            Evaluation bestSolEvaluation = l.getBestSolutionEvaluation();
            Validation bestSolValidation = l.getBestSolutionValidation();
            // if not null and different from current solution (i.e. improved):
            // update current and best solution accordingly
            if(bestSol != null && !bestSol.equals(getCurrentSolution())){
                updateCurrentAndBestSolution(bestSol, bestSolEvaluation, bestSolValidation);
            }
            // remove listener
            l.removeSearchListener(pipelineListener);
        });
        // pipeline complete: stop search
        stop();
    }
197342
public void execute() {

    while (!steps.isEmpty()) {
      currentStep = steps.remove(0);

      try {
        LOG.debugPerformOperationStep(currentStep.getName());

        currentStep.performOperationStep(this);
        successfulSteps.add(currentStep);

        LOG.debugSuccessfullyPerformedOperationStep(currentStep.getName());
      }
      catch (Exception e) {

        if(isRollbackOnFailure) {

          try {
            rollbackOperation();
          }
          catch(Exception e2) {
            LOG.exceptionWhileRollingBackOperation(e2);
          }
          // re-throw the original exception
          throw LOG.exceptionWhilePerformingOperationStep(name, currentStep.getName(), e);
        }

        else {
          LOG.exceptionWhilePerformingOperationStep(currentStep.getName(), e);
        }

      }
    }

  }
1032010
protected function _execute()
    {
        if (!$this->enabled() && !$this->focused()) {
            return;
        }
        foreach ($this->_children as $child) {
            if ($this->suite()->failfast()) {
                break;
            }
            $this->_passed = $child->process() && $this->_passed;
        }
    }
556888
public boolean run() {
        boolean passed;
        ExecutionToken t = createExecutionToken();
        List<FeatureToken> features = getFeatureList(t);
        startTests(t, features);
        initializeInterpreter();
        processFeatures(t, features);
        endTests(t, features);
        passed = t.getEndState() == EndState.PASSED || t.getEndState() == EndState.PENDING;
        dispose();
        return passed;
    }
499819
def execute(self, compiled=None, path=None, use_eval=False, allow_show=True):
        """"""
        self.check_runner()
        if compiled is not None:
            if allow_show and self.show:
                print(compiled)
            if path is not None:  # path means header is included, and thus encoding must be removed
                compiled = rem_encoding(compiled)
            self.runner.run(compiled, use_eval=use_eval, path=path, all_errors_exit=(path is not None))
            self.run_mypy(code=self.runner.was_run_code())
1106132
public final void execute() {
        try {
            Matcher<R> matcher = createMatcher();
            R result;
            if (input == null && timeout == null) {
                result = getExpect().expect(matcher);
            } else if (timeout == null) {
                result = getExpect().expectIn(input, matcher);
            } else if (input == null) {
                result = getExpect().expect(timeout, matcher);
            } else {
                result = getExpect().expectIn(input, timeout, matcher);
            }
            exportSuccessfulResult(resultPrefix, result);
        } catch (IOException e) {
            throw new BuildException(e);
        }
    }
472910
public void execute() {
        State currentState = state.getAndSet(State.RUNNING);
        if (currentState == State.RUNNING) {
            throw new IllegalStateException(
                    "ExecutionChain is already running!");
        }
        executeRunnable = new ExecuteRunnable();
    }