Add a step to the workflow.

        Args:
            step (Step): a step from the steps library.
557157
def _add_step(self, step):
        
        self._closed()

        self.has_workflow_step = self.has_workflow_step or step.is_workflow
        self.wf_steps[step.name_in_workflow] = step
724066
def add_after(self, pipeline):
        
        if not isinstance(pipeline, Pipeline):
            pipeline = Pipeline(pipeline)
        self.pipes = self.pipes[:] + pipeline.pipes[:]
        return self
743443
def transfer(self, to, **options):
        
        self._steps.append(Transfer(to, **options).obj)
4837
def step(self, count=1):
    """"""
    return self._client.send(step=sc_pb.RequestStep(count=count))
741235
def step(self) -> None:
        
        event = heappop(self._events)
        self._ts_now = event.timestamp or self._ts_now
        event.execute(self)
1084277
def step(self, **kwargs):
        
        kwargs.setdefault('linestyle', kwargs.pop('where', 'steps-post'))
        data = self.append(self.value[-1:], inplace=False)
        return data.plot(**kwargs)
428202
public function addStep(Step $step)
    {
        if (!$this->steps->contains($step)) {
            $this->steps->add($step);
        }

        return $this;
    }
828996
public void addStep(String name, String robot, Map<String, Object> options){
        steps.addStep(name, robot, options);
    }
299788
public void setStep(java.lang.Object _step) {
		getStateHelper().put(PropertyKeys.step, _step);
	}
1099980
def add_branch(steps, source_line, ruby_code = nil)
      branches << Branch.new(steps, source_line, ruby_code)
    end
1029794
def run_step(self, context):
        
        logger.debug("starting")
        # the in params should be added to context before step execution.
        self.set_step_input_context(context)

        if self.while_decorator:
            self.while_decorator.while_loop(context,
                                            self.run_foreach_or_conditional)
        else:
            self.run_foreach_or_conditional(context)

        logger.debug("done")
1021085
protected function add_step(question_attempt_step $step) {
        $this->steps[] = $step;
        end($this->steps);
        $this->observer->notify_step_added($step, $this, key($this->steps));
    }
1135639
def do_step(self, args):
        
        self._do_print_from_last_cmd = True
        self._interp.step_into()
        return True
524844
def go_to_step(self, step):
        
        self.stackedWidget.setCurrentWidget(step)

        # Disable the Next button unless new data already entered
        self.pbnNext.setEnabled(step.is_ready_to_next_step())

        # Enable the Back button unless it's not the first step
        self.pbnBack.setEnabled(
            step not in [self.step_kw_purpose, self.step_fc_functions1]
            or self.parent_step is not None)

        # Set Next button label
        if (step in [self.step_kw_summary, self.step_fc_analysis]
                and self.parent_step is None):
            self.pbnNext.setText(tr('Finish'))
        elif step == self.step_fc_summary:
            self.pbnNext.setText(tr('Run'))
        else:
            self.pbnNext.setText(tr('Next'))

        # Run analysis after switching to the new step
        if step == self.step_fc_analysis:
            self.step_fc_analysis.setup_and_run_analysis()

        # Set lblSelectCategory label if entering the kw mode
        # from the ifcw mode
        if step == self.step_kw_purpose and self.parent_step:
            if self.parent_step in [self.step_fc_hazlayer_from_canvas,
                                    self.step_fc_hazlayer_from_browser]:
                text_label = category_question_hazard
            elif self.parent_step in [self.step_fc_explayer_from_canvas,
                                      self.step_fc_explayer_from_browser]:
                text_label = category_question_exposure
            else:
                text_label = category_question_aggregation
            self.step_kw_purpose.lblSelectCategory.setText(text_label)
1020726
def start_step(self, lineno, name="Unnamed step", timestamp=None):
        """"""
        self.state = self.STATES['step_in_progress']
        self.stepnum += 1
        self.steps.append({
            "name": name,
            "started": timestamp,
            "started_linenumber": lineno,
            "errors": [],
        })
1260818
def _add_workflow(mcs, field_name, state_field, attrs):
        """"""
        attrs[field_name] = StateProperty(state_field.workflow, field_name)
818872
def increase_step(self) -> str:
        
        if self._steps_index < len(self._steps) - 1:
            self._steps_index = self._steps_index + 1
        return 'step: {}'.format(self.current_step())