Set group mute status.
770845
def set_muted(self, status):
        """"""
        self._group['muted'] = status
        yield from self._server.group_mute(self.identifier, status)
        _LOGGER.info('set muted to %s on %s', status, self.friendly_name)
258080
def change_channel_group(self, group):
        """"""
        assert self._probe is not None
        self._channels = _probe_channels(self._probe, group)
        self._positions = _probe_positions(self._probe, group)
481702
function mute (conn) {
  if (!conn.db) throw new Error('missing db');
  conn.db.removeAllListeners("close");
  conn.db.removeAllListeners("error");
  conn.db.removeAllListeners("timeout");
  conn.db.removeAllListeners("open");
  conn.db.removeAllListeners("fullsetup");
  conn._listening = false;
}
1072122
def groups_set_topic(self, room_id, topic, **kwargs):
        """"""
        return self.__call_api_post('groups.setTopic', roomId=room_id, topic=topic, kwargs=kwargs)
427472
def silence(cls, *modules, **kwargs):
        
        level = kwargs.pop("level", logging.WARNING)
        for mod in modules:
            name = mod.__name__ if hasattr(mod, "__name__") else mod
            logging.getLogger(name).setLevel(level)
704876
public function mute(bool $mute = true): SpeakerInterface
    {
        $this->speaker->mute($mute);
        return $this;
    }
456665
def get_speaker_muted(self):
        """"""
        if not self.camera_extended_properties:
            return None

        speaker = self.camera_extended_properties.get('speaker')
        if not speaker:
            return None

        return speaker.get('mute')
532738
def cmd(send, _, args):
    
    if args['target'] == 'private':
        send("You're all alone!")
        return
    with args['handler'].data_lock:
        channel = args['handler'].channels[args['target']]
        voiced = len([x for x in args['handler'].voiced[args['target']].values() if x])
        total = len(channel.users())
    send("%d active users, %d total users, %g%% active" % (voiced, total, voiced / total * 100))
711381
public function muted($status = false)
    {
        if($status) {
            $this->attributes['muted'] = true;
        } else {
            unset($this->attributes['muted']);
        }

        return $this;
    }
476565
def mute(self, mute):
        """"""
        try:
            if mute:
                if self.send_get_command(self._urls.command_mute_on):
                    self._mute = STATE_ON
                    return True
                else:
                    return False
            else:
                if self.send_get_command(self._urls.command_mute_off):
                    self._mute = STATE_OFF
                    return True
                else:
                    return False
        except requests.exceptions.RequestException:
            _LOGGER.error("Connection error: mute command not sent.")
            return False
630609
def set_mute(mute_value):
    ""
    all_mutes = ( \
            (0x8, 0x9), # LED page
            (0x1, 0xA7), # desktop page
            (0xb, 0x2f),
    )
    all_target_usages = [hid.get_full_usage_id(u[0], u[1]) for u in all_mutes]

    # usually you'll find and open the target device, here we'll browse for the
    # current connected devices
    all_devices = hid.find_all_hid_devices()

    success = 0
    if not all_devices:
        print("Can't any HID device!")
    else:
        # search for our target usage
        # target pageId, usageId
        for device in all_devices:
            try:
                device.open()
                # target 'to set' value could be in feature or output reports
                for report in device.find_output_reports() + device.find_feature_reports():
                    for target_usage in all_target_usages:
                        if target_usage in report:
                            # set our value and send
                            print("Found in report: {0}\n".format(report))

                            old_raw_data = report.get_raw_data()
                            print("  Empty raw report: {0}".format(old_raw_data))
                            report[target_usage] = value
                            new_raw_data = report.get_raw_data()
                            print("  Set raw report: {0}\n".format(new_raw_data))
                            # validate that set_raw_data() is working properly
                            report.set_raw_data( new_raw_data )
                            report.send()
                            success += 1
            finally:
                device.close()
    # fit to sys.exit() proper result values
    print("{0} Mute usage(s) set\n".format(success))
    if success:
        return 0
    return -1
1291645
def mute(ip):
        """"""
        tv_url = 'http://{}:6095/controller?action=keyevent&keycode='.format(ip)

        count = 0
        while count > 30:
            count = count + 1
            request = requests.get(tv_url + 'volumedown')

            if request.status_code != 200:
                return False

        return True
152872
function enable (context, loc, group, rules) {
  if (rules.length === 0) {
    context.report({ loc, message: '++ {{group}}', data: { group }})
  } else {
    context.report({ loc, message: '+ {{group}} {{rules}}', data: { group, rules: rules.join(' ') }})
  }
}
586329
def unmute():
	'''
	'''

	if system.get_name() == 'windows':
		# TODO: Implement volume for Windows. Looks like WinAPI is the
		# solution...
		pass

	elif system.get_name() == 'mac':
		sp.Popen(['osascript', '-e', 'set volume output muted false']).wait()

	else:
		# Linux/Unix
		if unix_is_pulseaudio_server():
			sp.Popen(['amixer', '--quiet', '-D', 'pulse', 'sset',
					  'Master', 'unmute']).wait()  # sset is *not* a typo

		else:
			sp.Popen(['amixer', '--quiet', 'sset', 'Master', 'unmute']).wait()
1175047
def mute():
	'''
	'''

	# NOTE: mute != 0 volume

	if system.get_name() == 'windows':
		# TODO: Implement volume for Windows. Looks like WinAPI is the
		# solution...
		pass

	elif system.get_name() == 'mac':
		sp.Popen(['osascript', '-e', 'set volume output muted true']).wait()

	else:
		# Linux/Unix
		if unix_is_pulseaudio_server():
			sp.Popen(['amixer', '--quiet', '-D', 'pulse', 'sset',
					  'Master', 'mute']).wait()  # sset is *not* a typo

		else:
			sp.Popen(['amixer', '--quiet', 'sset', 'Master', 'mute']).wait()
290254
function(mute) {
            if (!Crafty.support.audio) return;
            var c;
            for (var i in this.channels) {
                c = this.channels[i];
                c.obj.volume = mute ? 0 : c.volume;
            }
            this.muted = mute;
        }
1350568
def set_mute(self, enable):
        """"""
        data = '1' if enable else '0'
        params = ('<InstanceID>0</InstanceID><Channel>Master</Channel>'
                  '<DesiredMute>{}</DesiredMute>').format(data)
        self.soap_request(URL_CONTROL_DMR, URN_RENDERING_CONTROL,
                          'SetMute', params)