Perform step(action) on environments and update initial_frame_stack.
513136
def _step_envs(self, action):
    """"""
    self._frame_counter += 1
    real_env_step_tuple = self.real_env.step(action)
    sim_env_step_tuple = self.sim_env.step(action)
    self.sim_env.add_to_initial_stack(real_env_step_tuple[0])
    return self._pack_step_tuples(real_env_step_tuple, sim_env_step_tuple)
1363711
def step(self, exploration):
        
        if len(self._runners) > 1:
            self._populate_job_queue.put(exploration)
        else:
            self._runners[0].step(exploration)
918697
def step_next(self):
        """"""
        window_start = around(self.parent.value('window_start') +
                              self.parent.value('window_length') /
                              self.parent.value('window_step'), 2)

        self.parent.overview.update_position(window_start)
165355
Frame updateFrame(Frame target, Frame src) {
    if (src != target) ltrash(src);
    return src;
  }
404983
def update(self, redraw=True):
        """"""
        # get the main urwid.Frame widget
        mainframe = self.root_widget.original_widget

        # body
        if self.current_buffer:
            mainframe.set_body(self.current_buffer)

        # footer
        lines = []
        if self._notificationbar:  # .get_text()[0] != ' ':
            lines.append(self._notificationbar)
        if self._show_statusbar:
            lines.append(self.build_statusbar())

        if lines:
            mainframe.set_footer(urwid.Pile(lines))
        else:
            mainframe.set_footer(None)
        # force a screen redraw
        if self.mainloop.screen.started and redraw:
            self.mainloop.draw_screen()
738566
private function updateSteps()
    {
        $this->log('Initializing resource node of steps...');

        /** @var ObjectManager $om */
        $om = $this->container->get('claroline.persistence.object_manager');
        $steps = $om->getRepository('Innova\PathBundle\Entity\Step')->findAll();

        $om->startFlushSuite();
        $i = 0;

        /** @var Step $step */
        foreach ($steps as $step) {
            /** @var Activity $activity */
            $activity = $step->getActivity();

            if (!empty($activity)) {
                if (!empty($activity->getPrimaryResource())) {
                    $step->setResource($activity->getPrimaryResource());
                }
                $step->setTitle($activity->getResourceNode()->getName());
                $step->setDescription($activity->getDescription());

                $parameters = $activity->getParameters();

                if (!empty($parameters)) {
                    $order = 0;

                    foreach ($parameters->getSecondaryResources() as $resource) {
                        $secondaryResource = new SecondaryResource();
                        $secondaryResource->setResource($resource);
                        $secondaryResource->setOrder($order);
                        $step->addSecondaryResource($secondaryResource);
                        $om->persist($secondaryResource);
                        ++$order;
                    }
                }
                $om->persist($step);
            }
            ++$i;

            if ($i % 250 === 0) {
                $om->forceFlush();
            }
        }

        $om->endFlushSuite();
    }
444630
function runStep(file, version) {
	inProgress.version = version;
	return require.async('update/' + file).then(() => true)
	.catch(error => void console.error(`Update step for file "${ file  +'.js' }" failed with`, error));
}
623850
def _run_step(step_obj, step_declaration, initialized_resources):
    """"""

    start_time = time.time()

    # Open any resources that need to be opened before we run this step
    for res_name in step_declaration.resources.opened:
        initialized_resources[res_name].open()

    # Create a dictionary of all of the resources that are required for this step
    used_resources = {local_name: initialized_resources[global_name] for local_name, global_name in step_declaration.resources.used.items()}

    # Allow steps with no resources to not need a resources keyword parameter
    if len(used_resources) > 0:
        out = step_obj.run(resources=used_resources)
    else:
        out = step_obj.run()

    # Close any resources that need to be closed before we run this step
    for res_name in step_declaration.resources.closed:
        initialized_resources[res_name].close()

    end_time = time.time()

    return (end_time - start_time, out)
859420
private void createStackAndPushStartActivity(){
		activityStack = new Stack<WeakReference<Activity>>();
		if (activity != null && config.trackActivities){
			WeakReference<Activity> weakReference = new WeakReference<Activity>(activity);
			activity = null;
			activityStack.push(weakReference);
		}
	}
175868
def OnInit(self, profile=None, memoryProfile=None):
        """"""
        wx.Image.AddHandler(self.handler)
        frame = MainFrame( config_parser = load_config())
        frame.Show(True)
        self.SetTopWindow(frame)
        if profile:
            wx.CallAfter(frame.load, *[profile])
        elif sys.argv[1:]:
            if sys.argv[1] == '-m':
                if sys.argv[2:]:
                    wx.CallAfter( frame.load_memory, sys.argv[2] )
                else:
                    log.warn( 'No memory file specified' )
            else:
                wx.CallAfter(frame.load, *sys.argv[1:])
        return True
573166
def OnInit(self):
        """"""
        project = compass.CompassProjectParser(sys.argv[1]).parse()
        frame = MyFrame(None, -1, 'wxCompass', project)
        frame.Show(True)
        self.SetTopWindow(frame)
        return True
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);
        }

      }
    }

  }
1337437
def step(self, actions):
    
    for index, (env, action) in enumerate(zip(self._envs, actions)):
      if not env.action_space.contains(action):
        message = 'Invalid action at index {}: {}'
        raise ValueError(message.format(index, action))
    if self._blocking:
      transitions = [
          env.step(action)
          for env, action in zip(self._envs, actions)]
    else:
      transitions = [
          env.step(action, blocking=False)
          for env, action in zip(self._envs, actions)]
      transitions = [transition() for transition in transitions]
    observs, rewards, dones, infos = zip(*transitions)
    observ = np.stack(observs)
    reward = np.stack(rewards)
    done = np.stack(dones)
    info = tuple(infos)
    return observ, reward, done, info
772520
def setup_step_out(self, frame):
        
        self.frame_calling = None
        self.frame_stop = None
        self.frame_return = frame.f_back
        self.frame_suspend = False
        self.pending_stop = True 
        return
902666
def apply_step(project_root, environment, step)
      # Check if environment has configured the ssh keys
      (return warn _('wizard.provision.ssh_key_advice')%{environment: environment}) unless Bebox::Environment.check_environment_access(project_root, environment)
      nodes_to_step = Bebox::Node.nodes_in_environment(project_root, environment, previous_checkpoint(step))
      # Check if there are nodes for provisioning step-N
      (return warn _('wizard.provision.no_provision_nodes')%{step: step}) unless nodes_to_step.count > 0
      nodes_for_provisioning(nodes_to_step, step)
      # Apply the nodes provisioning for step-N
      in_step_nodes = Bebox::Node.list(project_root, environment, "steps/#{step}")
      outputs = []
      nodes_to_step.each do |node|
        next unless check_node_to_step(node, in_step_nodes, step)
        outputs << provision_step_in_node(project_root, environment, step, in_step_nodes, node)
      end
      return outputs
    end
485675
def update(self, frame_no):
        
        if (frame_no >= self._start_frame and
                (self._stop_frame == 0 or frame_no < self._stop_frame)):
            self._update(frame_no)
715910
def up(self):
        """"""
        if self.frame:
            self.frame = self.frame.f_back
            return self.frame is None