Abuses the bot.

    Syntax: {command}
8307
def cmd(send, _, args):
    

    def lenny_send(msg):
        send(gen_lenny(msg))

    key = args['config']['api']['bitlykey']
    cmds = [lambda: gen_fortune(lenny_send), lambda: gen_urban(lenny_send, args['db'], key)]
    choice(cmds)()
54905
def command(commands)
      command = Command.new(commands)
      server.remote_expr("VimrunnerEvaluateCommandOutput('#{command}')").tap do |output|
        raise InvalidCommandError.new(output) if output =~ /^Vim(\(call\))?:E\d+:/
      end
    end
175070
def to(self, command, **args):
        
        self.command = command
        self.args = args
        return self
894151
def cmd(send, msg, _):
    
    try:
        answer = subprocess.check_output(['wtf', msg], stderr=subprocess.STDOUT)
        send(answer.decode().strip().replace('\n', ' or ').replace('fuck', 'fsck'))
    except subprocess.CalledProcessError as ex:
        send(ex.output.decode().rstrip().splitlines()[0])
552681
function exec() {

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

  bag.command(__dirname, actions);
}
650373
def bots_create(self, bot):
        
        self.client.bots(_method="POST", _json=bot.to_json(), _params=dict(userToken=self.token))
984065
def as_command(self):
        
        try:
            params = self.unbound_func.__click_params__
            params.reverse()
            del self.unbound_func.__click_params__
        except AttributeError:
            params = []
        help = inspect.getdoc(self.real_func)
        if isinstance(help, bytes):
            help = help.decode('utf-8')
        self.options.setdefault('help', help)
        @pass_script_info_decorator
        def callback(info, *args, **kwargs):
            if self.with_reloader:
                app = info.load_app()
                if app.debug:
                    def inner():
                        return self.command_callback(info, *args, **kwargs)
                    run_with_reloader(inner, extra_files=get_reloader_extra_files())
                    return
            self.command_callback(info, *args, **kwargs)
        return self.cls(name=self.name, callback=callback, params=params, **self.options)
1245430
def process_command(command: CommandInput, matrix: VarMatrix) -> List[Command]:
    
    assert command is not None
    if isinstance(command, str):
        command_list = [Command(command, variables=variables) for variables in matrix]
    elif isinstance(command, list):
        command_list = [Command(command, variables=variables) for variables in matrix]
    else:
        if command.get("command") is not None:
            cmd = command.get("command")
        else:
            cmd = command.get("cmd")
        creates = str(command.get("creates", ""))
        requires = str(command.get("requires", ""))

        assert isinstance(cmd, (list, str))
        command_list = [
            Command(cmd, variables, creates, requires) for variables in matrix
        ]
    return uniqueify(command_list)
398345
def command(subcommand, *arguments)
        args = [vagrant, subcommand.to_s, arguments].flatten
        args.map {|a| Shellwords.escape a }.join(' ').tap do |command|
          logger.debug "Generated command '#{command}' from " +
            "subcommand '#{subcommand.to_s}' with arguments " +
            arguments.inspect
        end
      end
764000
def command(self, rule, **options):
        
        options.setdefault("direct", False)
        options.setdefault("override", True)
        options.setdefault("inject", False)
        options.setdefault("flags", 0)
        if not options["direct"]:
            rule = self.regexy(rule)
        regex = re.compile(rule, flags=options["flags"])
        self.handlers.setdefault(regex, [])
        def handler(f):
            if f == noop:
                f.options = {}
            else:
                f.options = options
            if options["override"]:
                self.handlers[regex] = [f]
            else:
                self.handlers[regex].append(f)
            f.no_args = self.no_args(f)
            return f
        return handler
1178838
def cmd(send, msg, args):
    
    parser = arguments.ArgParser(args['config'])
    group = parser.add_mutually_exclusive_group()
    group.add_argument('--clear', action='store_true')
    group.add_argument('--show', action='store_true')
    try:
        cmdargs = parser.parse_args(msg)
    except arguments.ArgumentException as e:
        send(str(e))
        return
    if cmdargs.clear:
        args['handler'].abuselist.clear()
        send("Abuse list cleared.")
    elif cmdargs.show:
        abusers = []
        for x in args['handler'].abuselist.keys():
            if args['db'].query(Ignore).filter(Ignore.nick == x).count():
                abusers.append(x)
        if abusers:
            send(", ".join(abusers))
        else:
            send("No abusers.")
    else:
        send("Please specify an option.")
351739
def exec(self, *command_tokens, **command_env):
		
		if self.match(*command_tokens, **command_env) is False:
			raise RuntimeError('Command mismatch: %s' % self.join_tokens(*command_tokens))

		return self._exec(*command_tokens, **command_env)
733403
def cmd(send, msg, args):
    
    implements = ['the golden gate bridge', 'a large trout', 'a clue-by-four', 'a fresh haddock', 'moon', 'an Itanium', 'fwilson', 'a wombat']
    methods = ['around a bit', 'upside the head']
    if not msg:
        channel = args['target'] if args['target'] != 'private' else args['config']['core']['channel']
        with args['handler'].data_lock:
            users = list(args['handler'].channels[channel].users())
        slap = 'slaps %s %s with %s'
        send(slap % (choice(users), choice(methods), choice(implements)), 'action')
    else:
        reason = ''
        method = choice(methods)
        implement = ''
        msg = msg.split()
        slapee = msg[0]
        # Basic and stupid NLP!
        i = 1
        args = False
        while i < len(msg):
            if msg[i] == 'for':
                args = True
                if reason:
                    send("Invalid Syntax: You can only have one for clause!")
                    return
                i += 1
                while i < len(msg):
                    if msg[i] == 'with':
                        break
                    reason += " "
                    reason += msg[i]
                    i += 1
                reason = reason.strip()
            elif msg[i] == 'with':
                args = True
                if implement:
                    send("Invalid Synatx: You can only have one with clause!")
                    return
                i += 1
                while i < len(msg):
                    if msg[i] == 'for':
                        break
                    implement += msg[i]
                    implement += ' '
                    i += 1
                implement = implement.strip()
            elif not args:
                slapee += ' ' + msg[i]
            i += 1

        if not implement:
            implement = choice(implements)
        if reason:
            slap = 'slaps %s %s with %s for %s' % (slapee, method, implement, reason)
        else:
            slap = 'slaps %s %s with %s' % (slapee, method, implement)
        send(slap, 'action')
1021939
function FilterCommand(value, engine) {
        var match = value.match(/^\s*([a-z0-9_-]+)\s*(\(([\s\S]*)\))?\s*$/i);
        if (!match) {
            throw new Error('Invalid ' + this.type + ' syntax: ' + value);
        }

        this.name = match[1];
        this.args = match[3];
        Command.call(this, value, engine);
        this.cloneProps = ['name', 'args'];
    }
232363
def act(self, cmd_name, param):
        
        command = getattr(self, cmd_name)
        if param:
            command(param)
        else:
            command()
1325798
def command(self, *args, **kwargs):
        
        def decorator(f):
            cmd = command(*args, **kwargs)(f)
            self.add_command(cmd)
            return cmd
        return decorator
1008774
def cmd(send, msg, args):
    
    if not msg or len(msg.split()) < 2:
        send("Pester needs at least two arguments.")
        return
    match = re.match('(%s+) (.*)' % args['config']['core']['nickregex'], msg)
    if match:
        message = match.group(2) + " "
        send('%s: %s' % (match.group(1), message * 3))
    else:
        send("Invalid Syntax.")