Constructs a ExecutionStepContext

        :param sid: Step Sid.

        :returns: twilio.rest.studio.v1.flow.execution.execution_step.ExecutionStepContext
        :rtype: twilio.rest.studio.v1.flow.execution.execution_step.ExecutionStepContext
18886
def get(self, sid):
        
        return ExecutionStepContext(
            self._version,
            flow_sid=self._solution['flow_sid'],
            execution_sid=self._solution['execution_sid'],
            sid=sid,
        )
856197
def get(self, sid):
        
        return AssetContext(self._version, service_sid=self._solution['service_sid'], sid=sid, )
470908
def get(self, sid):
        
        return EventContext(self._version, workspace_sid=self._solution['workspace_sid'], sid=sid, )
1360600
def get(self, sid):
        
        return SessionContext(self._version, service_sid=self._solution['service_sid'], sid=sid, )
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)
1178289
@Override
	public StepExecutionImpl createStepExecution(long rootJobExecId, StepContextImpl stepContext) {
		StepExecutionImpl stepExecution = null;
		String batchStatus = stepContext.getBatchStatus() == null ? BatchStatus.STARTING.name() : stepContext.getBatchStatus().name();
		String exitStatus = stepContext.getExitStatus();
		String stepName = stepContext.getStepName();
		if (logger.isLoggable(Level.FINE)) {
			logger.fine("batchStatus: " + batchStatus + " | stepName: " + stepName);
		}
		long readCount = 0;
		long writeCount = 0;
		long commitCount = 0;
		long rollbackCount = 0;
		long readSkipCount = 0;
		long processSkipCount = 0;
		long filterCount = 0;
		long writeSkipCount = 0;
		Timestamp startTime = stepContext.getStartTimeTS();
		Timestamp endTime = stepContext.getEndTimeTS();

		Metric[] metrics = stepContext.getMetrics();
		for (int i = 0; i < metrics.length; i++) {
			if (metrics[i].getType().equals(MetricImpl.MetricType.READ_COUNT)) {
				readCount = metrics[i].getValue();
			} else if (metrics[i].getType().equals(MetricImpl.MetricType.WRITE_COUNT)) {
				writeCount = metrics[i].getValue();	
			} else if (metrics[i].getType().equals(MetricImpl.MetricType.PROCESS_SKIP_COUNT)) {
				processSkipCount = metrics[i].getValue();	
			} else if (metrics[i].getType().equals(MetricImpl.MetricType.COMMIT_COUNT)) {
				commitCount = metrics[i].getValue();
			} else if (metrics[i].getType().equals(MetricImpl.MetricType.ROLLBACK_COUNT)) {
				rollbackCount = metrics[i].getValue();	
			} else if (metrics[i].getType().equals(MetricImpl.MetricType.READ_SKIP_COUNT)) {
				readSkipCount = metrics[i].getValue();
			} else if (metrics[i].getType().equals(MetricImpl.MetricType.FILTER_COUNT)) {
				filterCount = metrics[i].getValue();	
			} else if (metrics[i].getType().equals(MetricImpl.MetricType.WRITE_SKIP_COUNT)) {
				writeSkipCount = metrics[i].getValue();	
			}		
		}
		Serializable persistentData = stepContext.getPersistentUserData();

		stepExecution = createStepExecution(rootJobExecId, batchStatus, exitStatus, stepName, readCount, 
				writeCount, commitCount, rollbackCount, readSkipCount, processSkipCount, filterCount, writeSkipCount, startTime,
				endTime, persistentData);

		return stepExecution;
	}
473462
def get(self):
        
        return ExecutionContextContext(
            self._version,
            flow_sid=self._solution['flow_sid'],
            execution_sid=self._solution['execution_sid'],
        )
1244034
def get(self, sid):
        
        return ShortCodeContext(self._version, service_sid=self._solution['service_sid'], sid=sid, )
1315267
def get(self, sid):
        
        return EngagementContext(self._version, flow_sid=self._solution['flow_sid'], sid=sid, )
952447
def draw_step(self):
        
        ostep = self.ordering_step()
        for s in ostep:
            self.setxy()
            self.draw_edges()
            yield s
427341
function(sId, oBindingContext) {
									var oAvailableRoleType = oBindingContext.getObject();
									return new Item({
										key: oAvailableRoleType.key,
										text: oAvailableRoleType.text
									});
								}
1285405
async def execute(ctx):
    
    tail_depth = len(ctx.stack()) - 1

    story_part = ctx.get_current_story_part()
    logger.debug('# going to call: {}'.format(story_part.__name__))
    waiting_for = story_part(ctx.message)
    if inspect.iscoroutinefunction(story_part):
        waiting_for = await waiting_for
    logger.debug('# got result {}'.format(waiting_for))

    # story part could run callable story and return its context
    if isinstance(waiting_for, story_context.StoryContext):
        # for such cases is very important to know `tail_depth`
        # because story context from callable story already has
        # few stack items above our tail
        ctx = waiting_for.clone()
        ctx.waiting_for = callable.WaitForReturn()
    else:
        ctx = ctx.clone()
        ctx.waiting_for = waiting_for

    tail_data = ctx.message['session']['stack'][tail_depth]['data']
    tail_step = ctx.message['session']['stack'][tail_depth]['step']
    if ctx.is_waiting_for_input():
        if isinstance(ctx.waiting_for, callable.EndOfStory):
            if isinstance(ctx.waiting_for.data, dict):
                new_data = {**ctx.get_user_data(), **ctx.waiting_for.data}
            else:
                new_data = ctx.waiting_for.data
            ctx.message = {
                **ctx.message,
                'session': {
                    **ctx.message['session'],
                    'data': new_data,
                },
            }
            tail_step += 1
        elif isinstance(ctx.waiting_for, loop.ScopeMatcher):
            # jumping in a loop
            tail_data = matchers.serialize(ctx.waiting_for)
        elif isinstance(ctx.waiting_for, loop.BreakLoop):
            tail_step += 1
        else:
            tail_data = matchers.serialize(
                matchers.get_validator(ctx.waiting_for)
            )
            tail_step += 1

    ctx.message = modify_stack_in_message(ctx.message,
                                          lambda stack: stack[:tail_depth] +
                                                        [{
                                                            'data': tail_data,
                                                            'step': tail_step,
                                                            'topic': stack[tail_depth]['topic'],
                                                        }] +
                                                        stack[tail_depth + 1:])
    logger.debug('# mutated ctx after execute')
    logger.debug(ctx)
    return ctx
345019
def get(self, sid):
        
        return DialogueContext(self._version, assistant_sid=self._solution['assistant_sid'], sid=sid, )
1252714
private ExecutionMessage createTerminatedExecutionMessage(Execution nextStepExecution) {
        Payload payload = converter.createPayload(nextStepExecution); //we need the payload
        ExecutionMessage finalMessage = (ExecutionMessage) executionMessage.clone();
        finalMessage.setStatus(ExecStatus.TERMINATED); //in queue it is checked and finish flow is called
        finalMessage.incMsgSeqId();
        finalMessage.setPayload(payload);
        return finalMessage;
    }
958477
public function getContext($sid) {
        return new ExecutionStepContext(
            $this->version,
            $this->solution['flowSid'],
            $this->solution['executionSid'],
            $sid
        );
    }
175748
def get(self):
        
        return StepContextContext(
            self._version,
            flow_sid=self._solution['flow_sid'],
            engagement_sid=self._solution['engagement_sid'],
            step_sid=self._solution['step_sid'],
        )
760912
def build(steps)
      raise ArgumentError, "Must provide scenario steps" unless steps
      steps.each_with_index do |step, index|
        begin
          instruction, args = step.split ' ', 2
          args = split_quoted_string args
          if args && !args.empty?
            self.__send__ instruction, *args
          else
            self.__send__ instruction
          end
        rescue => e
          @errors << {step: index + 1, message: "#{step}: #{e.message}"}
        end
      end
    end