disable the alarm
182090
def alarm_disable(self):
        
        log.debug("alarm => disable...")
        params = {"enabled": False}
        self._app_exec("com.lametric.clock", "clock.alarm", params=params)
1283238
def disable(cls, args):
        """"""
        mgr = NAppsManager()

        if args['all']:
            napps = mgr.get_enabled()
        else:
            napps = args['<napp>']

        for napp in napps:
            mgr.set_napp(*napp)
            LOG.info('NApp %s:', mgr.napp_id)
            cls.disable_napp(mgr)
1127492
public static function disable()
    {

        if (self::isEnabled()) {
            // stop any timers still on stack (those might be stopped after calculation otherwise)
            $stackCopy = self::$stack;
            while ($timerName = array_pop($stackCopy)) {
                self::stop($timerName);
            }
        }
        self::$_enabled = false;

        self::calculate();
    }
781126
def stop(self):
        
        if self.stop_event.ready():  # not started
            return

        # Needs to come before any greenlets joining
        self.stop_event.set()

        # Filters must be uninstalled after the alarm task has stopped. Since
        # the events are polled by an alarm task callback, if the filters are
        # uninstalled before the alarm task is fully stopped the callback
        # `poll_blockchain_events` will fail.
        #
        # We need a timeout to prevent an endless loop from trying to
        # contact the disconnected client
        self.transport.stop()
        self.alarm.stop()

        self.transport.join()
        self.alarm.join()

        self.blockchain_events.uninstall_all_event_listeners()

        # Close storage DB to release internal DB lock
        self.wal.storage.conn.close()

        if self.db_lock is not None:
            self.db_lock.release()

        log.debug('Raiden Service stopped', node=pex(self.address))
976344
def off(self):
        """"""
        msg = X10Send.unit_code_msg(self.address.x10_housecode,
                                    self.address.x10_unitcode)
        self._send_method(msg)

        msg = X10Send.command_msg(self.address.x10_housecode,
                                  X10_COMMAND_OFF)
        self._send_method(msg, False)
        self._update_subscribers(0x00)
341005
function() {
    var self = this;

    // Get the Howl we want to manipulate.
    var sound = self.stations[self.index].howl;

    // Toggle the display.
    self.toggleStationDisplay(self.index, false);

    // Stop the sound.
    if (sound) {
      sound.unload();
    }
  }
514749
def destroy(self):
        
        builder = self.builder
        NotificationManager.cancel_notification(builder)
        del self.builder
        super(AndroidNotification, self).destroy()
793605
def remove(self):
        
        self.zone.alarmClock.DestroyAlarm([
            ('ID', self._alarm_id)
        ])
        alarm_id = self._alarm_id
        try:
            del Alarm._all_alarms[alarm_id]
        except KeyError:
            pass
        self._alarm_id = None
1132949
def delete_alarms(self, alarms):
        
        params = {}
        self.build_list_params(params, alarms, 'AlarmNames.member.%s')
        return self.get_status('DeleteAlarms', params)
468073
def Stop(self):
    """"""
    self._shutdown = True
    self._new_updates.set()  # Wake up the transmission thread.

    if self._main_thread is not None:
      self._main_thread.join()
      self._main_thread = None

    if self._transmission_thread is not None:
      self._transmission_thread.join()
      self._transmission_thread = None
77196
def event_listen_stop(self):
		''''''
		self._loop_stop = True
		c.pa.mainloop_wakeup(self._loop)
893639
def disable(name, **kwargs):
    '''
    
    '''
    if _service_is_upstart(name):
        return _upstart_disable(name)
    executable = _get_service_exec()
    cmd = [executable, '-f', name, 'remove']
    return not __salt__['cmd.retcode'](cmd, python_shell=False)
1050893
public void cancel()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "cancel", toString());  
    
    //flag this alarm as canceled (we don't remove it from the list immediately,
    // we leave it to be picked up by the alarm thread)
    active = false;
    
    // If this is a GroupAlarmListener it supports a cancel method, that we can call
    if(groupListener && (data != null))
      ((GroupAlarmListener)data).cancel();

    // Forget about the registered listener object and context
    data = null;
    groupListener = false;
    context = null;

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "cancel");
  }
563214
def p_disable(self, p):
        ''
        p[0] = Disable(p[2], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
1135005
def disable(self):
        """"""
        for arr in self:
            if arr.psy.plotter:
                arr.psy.plotter.disabled = True
504553
def do_not_disturb(self, enabled):
        """"""
        self._set_setting(
            {
                CONST.SETTINGS_DO_NOT_DISTURB: str(enabled).lower()
            })
509596
def disable_alarm_actions(self, alarm_names):
        
        params = {}
        self.build_list_params(params, alarm_names, 'AlarmNames.member.%s')
        return self.get_status('DisableAlarmActions', params)