This method sets only the 'active' current, i.e., the current for an
        axis' movement. Smoothie driver automatically resets the current for
        pipette axis to a low current (dwelling current) after each move
977154
def set_active_current(self, axis, amp):
        
        self._smoothie_driver.set_active_current({axis.name: amp})
1285152
def setTotal( self, amount ):
        
        self._primaryProgressBar.setValue(0)
        self._primaryProgressBar.setMaximum(amount)
        
        if amount:
            self.setCurrentMode(XLoaderWidget.Mode.Progress)
485322
public void setCurve(Curve curveRed, Curve curveGreen, Curve curveBlue) {
        this.curveRed = curveRed;
        this.curveGreen = curveGreen;
        this.curveBlue = curveBlue;
    }
576149
def set_current(self, current):
        
        self.current = current
        self.input = current.input
        # self.req = current.request
        # self.resp = current.response
        self.output = current.output
        self.cmd = current.task_data['cmd']

        if self.cmd and NEXT_CMD_SPLITTER in self.cmd:
            self.cmd, self.next_cmd = self.cmd.split(NEXT_CMD_SPLITTER)
        else:
            self.next_cmd = None
1189156
public void setActive(boolean active) {
		if (active == this.active)
			return;

		this.active = active;
		if (rayHandler == null)
			return;
		
		if (active) {
			rayHandler.lightList.add(this);
			rayHandler.disabledLights.removeValue(this, true);
		} else {
			rayHandler.disabledLights.add(this);
			rayHandler.lightList.removeValue(this, true);
		}
	}
1316780
protected function setCurrent()
    {
        if (0 === \count($this->buffer)) {
            $this->bufferize($this->types);
        }

        $this->current = array_pop($this->buffer);
    }
780575
def _update_pwm(self):
        """"""
        if self._is_on:
            values = self._get_pwm_values()
        else:
            values = [0] * len(self._driver.pins)

        self._driver.set_pwm(values)
307861
def set_current_limit(self, value, channel=1):
        
        cmd = "I%d %f" % (channel, value)
        self.write(cmd)
511806
def set_input(self, X_batch=None):
    
    inputs = self.inputs
    outputs = self.outputs

    # data for first gpu
    fd = {}
    if X_batch is not None:
      self.next_vals[0] = OrderedDict()
      for i, vname in enumerate(self.inputs[0]):
        if vname in X_batch:
          self.next_vals[0][vname] = X_batch[vname]
        else:
          self.next_vals[0][vname] = None
    else:
      self.next_vals[0] = None

    # Set `feed_dict` for each GPU. If there is something to run for that
    # GPU, collect outputs to be fetched.
    fetches = []
    self.active_gpus = []
    for i in range(len(outputs)):
      if self.next_vals[i] is None:
        self.active_gpus += [False]
        continue
      self.active_gpus += [True]
      for k in inputs[i]:
        if self.next_vals[i][k] is not None:
          fd[inputs[i][k]] = self.next_vals[i][k]
      for k, v in outputs[i].iteritems():
        fetches += [v]

    fd.update(self.feed_dict)

    return fetches, fd
892385
@SuppressWarnings("WeakerAccess")
    @UiThread
    public boolean popCurrentController() {
        ThreadUtils.ensureMainThread();

        RouterTransaction transaction = backstack.peek();
        if (transaction == null) {
            throw new IllegalStateException("Trying to pop the current controller when there are none on the backstack.");
        }
        return popController(transaction.controller);
    }
90033
@Override
	public void decrease(final int steps) throws IOException {

		if (currentValue == 0) {
			return;
		}
		if (steps < 0) {
			throw new RuntimeException("Only positive values for parameter 'steps' allowed!");
		}
		if (getNonVolatileMode() != MicrochipPotentiometerNonVolatileMode.VOLATILE_ONLY) {
			throw new RuntimeException("'decrease' is only valid for NonVolatileMode.VOLATILE_ONLY!");
		}

		// check boundaries
		final int actualSteps;
		if (steps > currentValue) {
			actualSteps = currentValue;
		} else {
			actualSteps = steps;
		}

		int newValue = currentValue - actualSteps;

		// if lower-boundary then set value in device to ensure sync
		// and for a large number of steps it is better to set a new value
		if ((newValue == 0)
				|| (steps > 5)) {

			setCurrentValue(newValue);

		}
		// for a small number of steps use 'decrease'-method
		else {

			controller.decrease(DeviceControllerChannel.valueOf(channel), actualSteps);

			currentValue = newValue;

		}

	}
123283
def set(self, is_on=None, brightness=None, cancel_transition=True):
        
        if cancel_transition:
            self._cancel_active_transition()

        if is_on is not None:
            self._is_on = is_on

        if brightness is not None:
            self._assert_is_brightness(brightness)
            self._brightness = brightness

        self._update_pwm()
1011869
private void setActiveGUI( final boolean isEnabled ) {
		SwingUtilities.invokeLater(new Runnable() {
			public void run() {
				toolbar.setEnabled(isEnabled);
				for( JComboBox b : algBoxes ) {
					b.setEnabled(isEnabled);
				}
				for( JComponent b : addedComponents ) {
					b.setEnabled(isEnabled);
				}
				imageBox.setEnabled(isEnabled);
			}
		});
	}
254737
def set_current(self, panel):
        
        where = slice(self._start_index, self._pos)
        self.buffer.values[:, where, :] = panel.values
537987
public void setActive(boolean active) {
        super.setActive(active);
        if (active) {
            this.start = new AtomicLong(System.currentTimeMillis());
        } else {
            this.start =new AtomicLong( -1);
        }
    }
1314832
def start(self):
        
        current_pedalboard = self.controller(CurrentController).pedalboard
        if current_pedalboard is None:
            self.log('Not exists any current pedalboard.')
            self.log('Use CurrentController to set the current pedalboard')
        else:
            self.log('Load current pedalboard - "{}"', current_pedalboard.name)

        self.mod_host.pedalboard = current_pedalboard

        for component in self.components:
            component.init()
            self.log('Load component - {}', component.__class__.__name__)

        self.log('Components loaded')
        atexit.register(self.stop)
1116763
def disconnect(self):
        
        if self._driver:
            self._driver.disconnect()

        self.axis_homed = {
            'x': False, 'y': False, 'z': False, 'a': False, 'b': False}