Start a new routine, stage or phase
969082
def start(self, phase, stage, **kwargs):
        """"""
        return ProgressSection(self, self._session, phase, stage, self._logger, **kwargs)
340168
private void startFixture(final String uuid, final FixtureResult result) {
        storage.put(uuid, result);
        result.setStage(Stage.RUNNING);
        result.setStart(System.currentTimeMillis());
        threadContext.clear();
        threadContext.start(uuid);
    }
1164803
def build_on_start(self, runnable, regime, on_start):
        

        on_start_code = []

        for action in on_start.actions:
            code = self.build_action(runnable, regime, action)
            for line in code:
                on_start_code += [line]

        return on_start_code
1310396
def start(self):
        """"""

        def cb():
            time_ = time.time()
            log.debug('Step {}'.format(time_))

            # run a step on all streams
            for d in self._dstreams:
                d._step(time_)

        self._pcb = PeriodicCallback(cb, self.batch_duration * 1000.0)
        self._pcb.start()
        self._on_stop_cb.append(self._pcb.stop)
        StreamingContext._activeContext = self
719315
def initialize(self):
        
        self.time.update(self.components.initial_time())
        self.time.stage = 'Initialization'
        super(Model, self).initialize()
1159248
def start(self):
        """"""
        self.run_task = self.pyvlx.loop.create_task(
            self.loop())
545419
def onStart(self, *args, **kwarg):
        
        with transactUI(self):
            config = self.navbar.getActiveConfig()
            config.resetErrors()
            if config.isValid():
                self.clientRunner.run(self.buildCliString())
                self.showConsole()
            else:
                config.displayErrors()
                self.Layout()
886684
function start()
{
    if (motor)
    {
        // configure it, for this example, we'll assume 200 steps per rev
        motor.configStepper(200);
        motor.setStepperSteps(100);
        // start it going at 10 RPM
        motor.enableStepper(mdObj.MD.STEP_DIR_CW, 10);
    }
}
283564
def start(**kwargs):
  '''  '''

  output, err = cli_syncthing_adapter.start(**kwargs)
  click.echo("%s" % output, err=err)
747774
def step(self):
        """"""
        if self.index >= len(self.tasklist):
            raise TaskError("step(): sequential compound task %s finished" % self)

        self.check_state()

        # Select next task from the set and advance the index
        self.task = self.tasklist[self.index]
        self.index += 1

        return self.runTask(self.task)
396537
def start(self, exit=True):
        '''
        '''
        if self.state == ACTOR_STATES.INITIAL:
            self._concurrency.before_start(self)
            self._concurrency.add_events(self)
            try:
                self.cfg.when_ready(self)
            except Exception:   # pragma    nocover
                self.logger.exception('Unhandled exception in when_ready hook')
            self._started = self._loop.time()
            self._exit = exit
            self.state = ACTOR_STATES.STARTING
            self._run()
769616
function start( next ) {
	/* jshint validthis:true */
	cnt += 1;

	this.rid = process.pid + ':' + cnt;

	this.start = null;
	this.end = null;
	this.timer = null;

	this.req = {
		'opts': this._opts,
		'body': this._body
	};
	this.res = {
		'status': null,
		'headers': null,
		'body': null,
		'bytes': 0
	};

	next();
}
603614
def run(self, incremental=None, run_id=None):
        """"""
        state = {
            'crawler': self.name,
            'run_id': run_id,
            'incremental': settings.INCREMENTAL
        }
        if incremental is not None:
            state['incremental'] = incremental

        # Cancel previous runs:
        self.cancel()
        # Flush out previous events:
        Event.delete(self)
        Queue.queue(self.init_stage, state, {})
568962
function start(mode, target, system, containerDef, container, out, cb) {
    if (mode !== 'preview') {
      main.setup(config, mode, target, system, containerDef, container, out, cb);
    } else {
      cb();
    }
  }
465875
protected void beginStage(final String header, final String stage,
            final String numStages) {
        boolean print = getPhaseConfiguration().isVerbose();
        if (print) {
            StringBuilder bldr = new StringBuilder();
            bldr.append(INDENT);
            bldr.append("Stage ");
            bldr.append(stage);
            bldr.append(" of ");
            bldr.append(numStages);
            bldr.append(": ");
            bldr.append(header);
            reportable.output(bldr.toString());
        }
    }
295540
def on_train_begin(self, epoch:int, **kwargs:Any)->None:
        ""
        res = {'epoch':self.start_epoch} if self.start_epoch is not None else None
        self.start_epoch = ifnone(self.start_epoch, epoch)
        self.scheds = [p.scheds for p in self.phases]
        self.opt = self.learn.opt
        for k,v in self.scheds[0].items(): 
            v.restart()
            self.opt.set_stat(k, v.start)
        self.idx_s = 0
        return res
141779
def add_step(self, setting, duration):
        
        if len(self._prog_steps) < 10:
            self._prog_steps.append(ProgramStep(self, setting, duration))
        else:
            raise IndexError("Maximum of 10 steps are allowed")