Set the maximum central heating setpoint. This command is only
        available with boilers that support this function.
        Return the newly accepted setpoint, or None on failure.

        This method is a coroutine
518847
async def set_max_ch_setpoint(self, temperature,
                                  timeout=OTGW_DEFAULT_TIMEOUT):
        
        cmd = OTGW_CMD_SET_MAX
        status = {}
        ret = await self._wait_for_cmd(cmd, temperature, timeout)
        if ret is None:
            return
        ret = float(ret)
        status[DATA_MAX_CH_SETPOINT] = ret
        self._update_status(status)
        return ret
1329053
async def set_heating_level(self, level, duration=0):
        """"""
        url = '{}/devices/{}'.format(API_URL, self.device.deviceid)

        # Catch bad inputs
        level = 10 if level < 10 else level
        level = 100 if level > 100 else level

        if self.side == 'left':
            data = {
                'leftHeatingDuration': duration,
                'leftTargetHeatingLevel': level
            }
        elif self.side == 'right':
            data = {
                'rightHeatingDuration': duration,
                'rightTargetHeatingLevel': level
            }

        set_heat = await self.device.api_put(url, data)
        if set_heat is None:
            _LOGGER.error('Unable to set eight heating level.')
        else:
            # Standard device json is returned after setting
            self.device.handle_device_json(set_heat['device'])
762964
def set_max_workers(self, nb):
        
        self.count_lock.acquire()
        self.max_workers = nb
        if self.workers > self.max_workers:
            self.kill(self.workers - self.max_workers)
        self.count_lock.release()
170713
def upper(self) -> Set[Point2]:
        
        max_height = max([self.height_at(p) for p in self._points])
        return {p for p in self._points if self.height_at(p) == max_height}
293818
public void setMaxConcurrency(final String maxConcurrency) {

        if (TraceComponent.isAnyTracingEnabled() && TRACE.isDebugEnabled()) {
            SibTr.debug(this, TRACE, "MaxConcurrency", maxConcurrency);
        }
        _maxConcurrency = (maxConcurrency == null ? null : Integer.valueOf(maxConcurrency));

    }
571654
public void setRange(final double MIN_VALUE, final double MAX_VALUE) {
        maxValue = MAX_VALUE;
        minValue = MIN_VALUE;
        calculate();
        validate();
        calcAngleStep();
        fireStateChanged();
    }
375729
def setOutputPoint(self, point):
        
        self._outputPoint = point
        self.setPath(self.rebuild())
583961
def init_timer(self, max_value):
    
    self.__max_value = max_value
    self.__prev_tick = time.time()
    self.__unit_per_sec = 0
    self.__unit_per_sec_prev = 0
108586
public void setMax(Double max) {
        String maxStr = doubleToNiceStr(max);
        JQMCommon.setAttribute(input, "max", maxStr);
        refreshMax(input.getElement().getId(), maxStr);
        validateValue();
    }
504455
private void createTempPoint() {
		tempPoint = new GfxGeometry("PointDrawController.updatePoint");
		tempPoint.setStyle(drawStyle);
		tempPoint.setSymbolInfo(symbolStyle);

		Coordinate coords = getTransformer().worldToPan(geometry.getCoordinate());
		Point point = (Point) geometry.getGeometryFactory().createPoint(coords);
		tempPoint.setGeometry(point);
		mapWidget.render(tempPoint, RenderGroup.VECTOR, RenderStatus.ALL);
	}
855396
public void setMax(int max)
    {
        this.max = max;
        if (this.max < Alterable.MIN)
        {
            this.max = Alterable.MIN;
        }
        set(cur);
    }
1269274
public void setExecutorTaskMax(int max)
  {
    if (getThreadMax() < max)
      throw new ConfigException(L.l("<thread-executor-max> ({0}) must be less than <thread-max> ({1})",
                                    max, getThreadMax()));

    if (max == 0)
      throw new ConfigException(L.l("<thread-executor-max> must not be zero."));

    _executorTaskMax = max;
  }
950386
def setStation(self, number):
        
        # If we press up at the first station, we go to the last one
        # and if we press down on the last one we go back to the first one.
        if number < 0:
            number = len(self.stations) - 1
        elif number >= len(self.stations):
            number = 0

        self.selection = number

        maxDisplayedItems = self.bodyMaxY - 2
        if self.selection - self.startPos >= maxDisplayedItems:
            self.startPos = self.selection - maxDisplayedItems + 1
        elif self.selection < self.startPos:
            self.startPos = self.selection
263280
def set_bpp(self, bpp):
        
        self.bpp = bpp
        self.maxc = 2 ** self.bpp - 1
        self._set_dtype()
        self.calc_cmap()
        self.recalc(callback=False)
148253
def set_max(self):
        """"""
        if not self.__maxrange_state:
            data = self._controller.command(self._id, 'charge_max_range',
                                            wake_if_asleep=True)
            if data['response']['result']:
                self.__maxrange_state = True
            self.__manual_update_time = time.time()
881585
def set_heater(self, heater):
        
        if type(heater) != int and heater not in range(0, 101):
            raise InvalidInput("Heater value must be int between 0-100")
        self._config['heater'] = heater
        self._q.put(self._config)
1197924
def set_temperature(self, zone, temperature, until=None):
        """"""
        if until is None:
            data = {"Value": temperature, "Status": "Hold", "NextTime": None}
        else:
            data = {"Value": temperature,
                    "Status": "Temporary",
                    "NextTime": until.strftime('%Y-%m-%dT%H:%M:%SZ')}

        self._set_heat_setpoint(zone, data)