Turn the relay off.
2915
def set_relay_off(self):
        """"""
        if self.get_relay_state():
            try:
                request = requests.get(
                    '{}/relay'.format(self.resource), params={'state': '0'},
                    timeout=self.timeout)
                if request.status_code == 200:
                    self.data['relay'] = False
            except requests.exceptions.ConnectionError:
                raise exceptions.MyStromConnectionError()
488533
def disconnect(self):
        """"""
        self.target_device.disconnect()
        self.ctrl.disconnect()
        self.tail_disconnect(-1)
1330801
def disable(self):
        

        self.ticker_text_label.hide()
        if self.current_observed_sm_m:
            self.stop_sm_m_observation(self.current_observed_sm_m)
120660
function off(element, type, handler, opt) {
    util.removeEventListener(element, type, handler, opt, true);
  }
1247425
def _hide(self):
        """"""
        self._icon.set_visible(False)
        self._icon.disconnect(self._conn_left)
        self._icon.disconnect(self._conn_right)
        self._conn_left = None
        self._conn_right = None
831902
def Stop(self):
    """"""
    if not self.__running:
      return
    logging.info('shutting down the emulator running at %s', self._host)
    headers = {'Content-length': '0'}
    response, _ = self._http.request('%s/shutdown' % self._host,
                                     method='POST', headers=headers)
    if response.status != 200:
      logging.warning('failed to shut down emulator; response: %s', response)

    self.__running = False
    # Delete temp files.
    shutil.rmtree(self._tmp_dir)
909008
def turn_off(self) -> "Signal":
        
        if _logger is not None:
            self._log(INFO, "turn-off")
        self._is_on = False
        return self
570573
def shutdown(self):
        """"""
        if not self._stop_evt:
            return  # pool is already stopped
        self.reactor.removeSystemEventTrigger(self._stop_evt)
        self._stop()
1107563
public synchronized void stop()
    {
        if( null != m_pump )
        {
            // disconnect pump
            m_pump.connect( null );
            m_pump.setName( m_pump.getName() + " (disconnected)" );
            m_pump = null;
        }
    }
639183
def stop(self):
        """"""
        args = self.getShutdownArgs() + ['shutdown']
        Pyro.nsc.main(args)
        self.join()
820863
def disable(self):
        
        w.ActButton.disable(self)
        g = get_root(self).globals
        if self._expert:
            self.config(bg=g.COL['start'])
        else:
            self.config(bg=g.COL['startD'])
527640
def stop(self):
        
        with self.condition:
            self.running = False
            self.condition.notify_all()
1306163
def power_off(self):
        """"""
        try:
            self.send_command("POWER_OFF")
            self._power = POWER_OFF
            self._state = STATE_OFF
            return True
        except requests.exceptions.RequestException:
            _LOGGER.error("Connection error: power off command not sent.")
            return False
1163889
def stop(self):
        """"""
        with self._operational_lock:
            self._bidi_rpc.close()

            if self._thread is not None:
                # Resume the thread to wake it up in case it is sleeping.
                self.resume()
                self._thread.join()

            self._thread = None
1351661
def stop(self):
        
        self._stop.set()
        if self._channel is not None:
            self._channel.close()
436541
async def stop(self):
        """"""

        if self._rpc_task is not None:
            self._rpc_task.cancel()

        try:
            await self._rpc_task
        except asyncio.CancelledError:
            pass

        self._rpc_task = None
811146
def stop(self, timeout_s=None):
    """"""
    self._live = False
    try:
      self._sock.shutdown(socket.SHUT_RDWR)
      self._sock.close()
    except socket.error:
      pass
    self.join(timeout_s)