Microwaves something.

    Syntax: {command} <level> <target>
179314
def cmd(send, msg, args):
    
    nick = args['nick']
    channel = args['target'] if args['target'] != 'private' else args['config']['core']['channel']
    levels = {
        1: 'Whirr...',
        2: 'Vrrm...',
        3: 'Zzzzhhhh...',
        4: 'SHFRRRRM...',
        5: 'GEEEEZZSH...',
        6: 'PLAAAAIIID...',
        7: 'KKKRRRAAKKKAAKRAKKGGARGHGIZZZZ...',
        8: 'Nuke',
        9: 'nneeeaaaooowwwwww..... BOOOOOSH BLAM KABOOM',
        10: 'ssh root@remote.tjhsst.edu rm -rf ~%s'
    }
    if not msg:
        send('What to microwave?')
        return
    match = re.match('(-?[0-9]*) (.*)', msg)
    if not match:
        send('Power level?')
    else:
        level = int(match.group(1))
        target = match.group(2)
        if level > 10:
            send('Aborting to prevent extinction of human race.')
            return
        if level < 1:
            send('Anti-matter not yet implemented.')
            return
        if level > 7:
            if not args['is_admin'](nick):
                send("I'm sorry. Nukes are a admin-only feature")
                return
            elif msg == args['botnick']:
                send("Sorry, Self-Nuking is disabled pending aquisition of a Lead-Lined Fridge.")
            else:
                with args['handler'].data_lock:
                    if target not in args['handler'].channels[channel].users():
                        send("I'm sorry. Anonymous Nuking is not allowed")
                        return

        msg = levels[1]
        for i in range(2, level + 1):
            if i < 8:
                msg += ' ' + levels[i]
        send(msg)
        if level >= 8:
            do_nuke(args['handler'].connection, nick, target, channel)
        if level >= 9:
            send(levels[9])
        if level == 10:
            send(levels[10] % target)
        send('Ding, your %s is ready.' % target)
243029
def exec(self, command_str, **command_env):
		
		env = self.__vars.copy()
		env.update(command_env)

		command_tokens = WCommandProto.split_command(command_str)
		command_obj = self.commands().select(*command_tokens, **env)
		if command_obj is None:
			raise WCommandSet.NoCommandFound('No suitable command found: "%s"' % command_str)

		result = command_obj.exec(*command_tokens, **env)
		self.__track_vars(result)
		return result
257075
def command(name, nargs=0, complete=None, range=None, count=None, bang=False,
            register=False, sync=False, allow_nested=False, eval=None):
    """"""
    def dec(f):
        f._nvim_rpc_method_name = 'command:{}'.format(name)
        f._nvim_rpc_sync = sync
        f._nvim_bind = True
        f._nvim_prefix_plugin_path = True

        opts = {}

        if range is not None:
            opts['range'] = '' if range is True else str(range)
        elif count is not None:
            opts['count'] = count

        if bang:
            opts['bang'] = ''

        if register:
            opts['register'] = ''

        if nargs:
            opts['nargs'] = nargs

        if complete:
            opts['complete'] = complete

        if eval:
            opts['eval'] = eval

        if not sync and allow_nested:
            rpc_sync = "urgent"
        else:
            rpc_sync = sync

        f._nvim_rpc_spec = {
            'type': 'command',
            'name': name,
            'sync': rpc_sync,
            'opts': opts
        }
        return f
    return dec
572263
def _handle_command(self, connection, sender, target, command, payload):
        
        try:
            # Find the handler
            handler = getattr(self, "cmd_{0}".format(command))
        except AttributeError:
            self.safe_send(connection, target, "Unknown command: %s",
                            command)
        else:
            try:
                logging.info("! Handling command: %s", command)
                handler(connection, sender, target, payload)
            except Exception as ex:
                logging.exception("Error calling command handler: %s", ex)
1167364
private void processIfCmd(String parms, int cmdTPosBegin, int cmdTPosEnd)
            throws MiniTemplator.TemplateSyntaxException {
        excludeTemplateRange(cmdTPosBegin, cmdTPosEnd);
        if (condLevel >= maxCondLevels - 1) {
            throw new MiniTemplator.TemplateSyntaxException("Too many nested $if commands.");
        }
        condLevel++;
        boolean enabled = isCondEnabled(condLevel - 1) && evaluateConditionFlags(parms);
        condEnabled[condLevel] = enabled;
        condPassed[condLevel] = enabled;
    }
987673
function process(parent, index, commands) {
    var cmd = commands[index],
        ret;

    switch (cmd.value[0].type) {
        case ConkittyTypes.TEMPLATE_NAME:
            ret = processCall(parent, false, cmd);
            break;

        case ConkittyTypes.COMMAND_NAME:
            switch (cmd.value[0].value) {
                case 'ATTR':
                    ret = processAttr(parent, true, cmd);
                    break;

                case 'CALL':
                    ret = processCall(parent, true, cmd, commands[index + 1]);
                    break;

                case 'CHOOSE':
                    ret = processChoose(parent, cmd);
                    break;

                case 'EACH':
                    ret = processEach(parent, cmd, commands[index + 1]);
                    break;

                case 'EXPOSE':
                    ret = processExpose(parent, cmd);
                    break;

                case 'JS':
                    ret = processJS(parent, cmd);
                    break;

                case 'MEM':
                    ret = processMem(parent, cmd);
                    break;

                case 'PAYLOAD':
                    ret = processPayload(parent, cmd);
                    break;

                case 'SET':
                    ret = processSet(parent, cmd);
                    break;

                case 'TEST':
                    ret = processTest(parent, cmd);
                    break;

                case 'TRIGGER':
                    ret = processTrigger(parent, cmd);
                    break;

                case 'WITH':
                    ret = processWith(parent, cmd, commands[index + 1]);
                    break;

                default:
                    throw new ConkittyErrors.InconsistentCommand(cmd.value[0]);
            }

            break;

        case ConkittyTypes.VARIABLE:
            ret = processVariable(parent, cmd);
            break;

        case ConkittyTypes.JAVASCRIPT:
            ret = processJavascript(parent, cmd);
            break;

        case ConkittyTypes.STRING:
            ret = processString(parent, cmd);
            break;

        case ConkittyTypes.CSS:
            ret = processElement(parent, cmd);
            break;

        case ConkittyTypes.ATTR:
            ret = processAttr(parent, false, cmd);
            break;

        case ConkittyTypes.INCLUDE:
            ret = processInclude(parent, cmd);
            break;

        case ConkittyTypes.NODE_APPENDER:
            ret = processAppender(parent, cmd);
            break;

        default:
            throw new ConkittyErrors.InconsistentCommand(cmd.value[0]);
    }

    return index + ret;
}
1282798
function emitGameCommandMsg(node, msg) {
        var opts;
        if ('string' !== typeof msg.text) {
            node.err('"in.' + msg.action + '.GAMECOMMAND": msg.text must be ' +
                     'string. Found: ' + msg.text);
            return false;
        }
        if (!parent.constants.gamecommands[msg.text]) {
            node.err('"in.' + msg.action + '.GAMECOMMAND": unknown game  ' +
                     'command received: ' + msg.text);
            return false;
        }

        opts = 'string' === typeof msg.data ? J.parse(msg.data) : msg.data;
        return node.emit('NODEGAME_GAMECOMMAND_' + msg.text, opts);
    }
967576
def cmd(send, msg, args):
    
    if not msg:
        msg = gen_word()
    send(gen_intensify(msg))
552681
function exec() {

  var actions = {
    commands: {
      'delete': { action: _delete },
      screenshot: { action: _screenshot }
    }
  };

  bag.command(__dirname, actions);
}
1136111
function commands(req, res /*, next */) {
  req.app.commands.forEach(function(command) {
    res.writeln(command);
  });
  res.end();
}
1330042
function CommandProcessor(conn) {
	events.EventEmitter.call(this);

	this.conn = conn;

	this.connected_at = +new Date();
	this.last_data_at = 0;
	this.last_ping_at = 0;

	p.data_timeout = -1; // disabled
	p.data_timeout_TID = null;

	p.ping_timeout = -1; // disabled
	p.ping_timeout_TID = null;

	this._request_id = 0;
	this._requests_in_flight = {};

	this.last_line   = '';

	// handling disconnection can only be done once
	var _handle_disconnection = _.once(this._handle_disconnection.bind(this));

	conn.on('data',  this.process_data.bind(this));
	conn.on('error', _handle_disconnection);
	conn.on('end',   _handle_disconnection); // Do we really need this?
	conn.on('close', _handle_disconnection);

	// bind some methods to current instance for easy reuse
	this._emit_data_timeout = this._emit_data_timeout .bind(this);
	this._emit_ping_timeout = this._emit_ping_timeout .bind(this);
	this.set_timeouts();
}
725450
function init(entry, target, command, data) {  // {{{2
/**
 * Socket constructor
 *
 * @param entry {Object} Source entry
 * @param target {Number|String|Object} Target entry identification
 * @param command {String} Command name
 * @param [data] {*} Optional data
 *
 * @method constructor
 */

  this.entry = entry;
  this.command = command;
  this.target = target;

  this.data = data || {};
  if (! this.data.entry) {
    this.data.entry = entry.getIdent();
  }
  if (! this.data.caption) {
    this.data.caption = entry.getCaption();
  }

  switch (typeof target) {
  case 'number':
  case 'string':
    this.shard = entry.shard;
    this.targetId = target;
    return connect(this);
  case 'object':
    return connect(this);
  }

  throw O.log.error(entry, 'INVALID_ARGS', arguments);
}
1364314
function CommandRouter(webhook) {
    this.commands = {};
    
    // add router as (messages/created) listener
    if (!webhook) {
        debug("webhook required, skipping router initialization...");
        return;
    }
    this.webhook = webhook;

    var self = this;
    webhook.onMessage(function(trigger, message) {
        var command = webhook.asCommand(message);
        if (!command || !command.keyword) {
            debug("could not interpret message as a command, aborting..."); 
            return;
        }
            
        fine("new command: " + command.keyword + ", with args: " + JSON.stringify(command.args));
        var listener = self.commands[command.keyword];
        if (!listener) {
            fine("no listener for command: " + command.keyword);

            // Looking for a fallback listener 
            listener = self.commands["fallback"];
            if (listener) {
                debug("found fallback listener => invoking");
                listener(command);
            }
            return;
        }

        debug("firing new command: " + command.keyword);
        listener(command);
    });
}
1040368
def target_heating_level(self):
        """"""
        try:
            if self.side == 'left':
                level = self.device.device_data['leftTargetHeatingLevel']
            elif self.side == 'right':
                level = self.device.device_data['rightTargetHeatingLevel']
            return level
        except TypeError:
            return None
129693
function ChildProcess (command, args, env, code, maxBuffer) {
        var self = this;

        assert.string(command);
        assert.optionalArrayOfNumber(code);

        self.command = command;
        self.file = self._parseCommandPath(self.command);
        self.args = args;
        self.environment = env || {};
        self.exitCode = code || [0];
        self.maxBuffer = maxBuffer || Constants.ChildProcess.MaxBuffer;

        if (!self.file) {
            throw new Error('Unable to locate command file (' + self.command +').');
        }
        if (!_.isEmpty(self.args)) {
            try {
                assert.arrayOfString(self.args, 'ChildProcess command arguments');
            } catch (e) {
                throw new Error('args must be an array of strings');
            }
        }

        self.hasBeenKilled = false;
        self.hasBeenCancelled = false;
        self.spawnInstance = undefined;
    }
884449
def cmd(send, msg, args):
    
    parser = arguments.ArgParser(args['config'])
    parser.add_argument('--chan', '--channel', action=arguments.ChanParser)
    try:
        cmdargs, extra = parser.parse_known_args(msg)
    except arguments.ArgumentException as e:
        send(str(e))
        return
    target = cmdargs.channels[0] if hasattr(cmdargs, 'channels') else args['target']
    mode = " ".join(extra)
    if not mode:
        send('Please specify a mode.')
    elif target == 'private':
        send("Modes don't work in a PM!")
    else:
        with args['handler'].data_lock:
            if target not in args['handler'].channels:
                send("Bot not in channel %s" % target)
            elif args['botnick'] not in args['handler'].opers[target]:
                send("Bot must be opped in channel %s" % target)
            else:
                args['handler'].connection.mode(target, mode)
                if args['target'] != args['config']['core']['ctrlchan']:
                    send("Mode \"%s\" on %s by %s" % (mode, target, args['nick']), target=args['config']['core']['ctrlchan'])
1283826
function doExec(callback, command) {
    let args = Array.prototype.slice.call(arguments);
    args.splice(0, 2);  //remove the first cb and command
    if (!this.isConnected()) {
      return callback(thorin.error('REDIS.NOT_CONNECTED', 'The connection is not active yet.'));
    }
    command = command.toLowerCase();
    if (typeof this[connections].default.connection[command] !== 'function') {
      return callback(thorin.error('REDIS.COMMAND_NOT_FOUND', 'Invalid command issued: ' + command, 500));
    }
    args.push((err, res) => {
      if (err) {
        return callback(thorin.error('REDIS.EXEC', 'Redis command failed to execute.', err));
      }
      if (command === 'hgetall' && typeof res === 'object' && res) {
        // backward compatibility
        if (Object.keys(res).length === 0) {
          res = null;
        }
      }
      callback(null, res);
    });
    this[connections].default.emit('command', command, args);
    this[connections].default.connection[command].apply(this[connections].default.connection, args);
  }