Unsupported in the Bot API
430035
def message_search(self, text, on_success, peer=None, min_date=None, max_date=None, max_id=None, offset=0, limit=255):
        
        raise TWXUnsupportedMethod()
1106691
def content_allows_robots (self):
        
        if not self.is_html():
            return True
        # construct parser object
        handler = linkparse.MetaRobotsFinder()
        parser = htmlsax.parser(handler)
        handler.parser = parser
        if self.charset:
            parser.encoding = self.charset
        # parse
        try:
            parser.feed(self.get_content())
            parser.flush()
        except linkparse.StopParse as msg:
            log.debug(LOG_CHECK, "Stopped parsing: %s", msg)
            pass
        # break cyclic dependencies
        handler.parser = None
        parser.handler = None
        return handler.follow
1266385
private function isExceptionFromBot()
    {
        $ignored_bots = $this->config->get('sneaker.ignored_bots');

        $agent = array_key_exists('HTTP_USER_AGENT', $_SERVER)
                    ? strtolower($_SERVER['HTTP_USER_AGENT'])
                    : null;

        if (is_null($agent)) {
            return false;
        }

        foreach ($ignored_bots as $bot) {
            if ((strpos($agent, $bot) !== false)) {
                return true;
            }
        }

        return false;
    }
107424
private static BotMillNetworkResponse postInternal(String url,
			StringEntity input) {
		BotMillNetworkResponse response = NetworkUtils.post(url, input);
		propagateResponse(response);
		return response;
	}
424575
def _raise_on_unsupported_token(self, request):
        """"""
        if (request.token_type_hint and
            request.token_type_hint in self.valid_token_types and
            request.token_type_hint not in self.supported_token_types):
            raise UnsupportedTokenTypeError(request=request)
717119
def get(self, request, bot_id, format=None):
        
        return super(StateList, self).get(request, bot_id, format)
410231
function ExampleBot(bot_id) {
    this.bot_id      = bot_id;         //ID of bot for logging
    this.nickname    = 'agario-client';//default nickname
    this.verbose     = true;           //default logging enabled
    this.interval_id = 0;              //here we will store setInterval's ID

    this.server     = '';   //server address will be stored here
    this.server_key = '';   //server key will be stored here

    this.client       = new AgarioClient('Bot ' + this.bot_id); //create new client
    this.client.debug = 1; //lets set debug to 1
}
457522
function getReply(req, res) {
	// Get data from the JSON post.
	var username = req.body.username;
	var message  = req.body.message;
	var vars     = req.body.vars;

	// Make sure username and message are included.
	if (typeof(username) === "undefined" || typeof(message) === "undefined") {
		return error(res, "username and message are required keys");
	}

	// Copy any user vars from the post into RiveScript.
	if (typeof(vars) !== "undefined") {
		for (var key in vars) {
			if (vars.hasOwnProperty(key)) {
				bot.setUservar(username, key, vars[key]);
			}
		}
	}

	// Get a reply from the bot.
	bot.reply(username, message, this).then(function(reply) {
		// Get all the user's vars back out of the bot to include in the response.
		vars = bot.getUservars(username);

		// Send the JSON response.
		res.json({
			"status": "ok",
			"reply": reply,
			"vars": vars
		});
	}).catch(function(err) {
		res.json({
			"status": "error",
			"error": err
		});
	});
}
1195685
function unsupportedExpression(node){
  console.error(node)
  var err = new Error('Unsupported expression: ' + node.type)
  err.node = node
  throw err
}
1041272
function getReply(bot, username, message) {
	var filename = "./" + username + ".json";

	// See if the bot knows this user yet (in its current memory).
	var userData = bot.getUservars(username);
	if (!userData) {
		// See if a local file exists for stored user variables.
		try {
			var stats = fs.statSync(filename);
			if (stats) {
				var jsonText = fs.readFileSync(filename);
				userData = JSON.parse(jsonText);
				bot.setUservars(username, userData);
			}
		} catch(e) {}
	}

	// Wrap the reply promise so we can export user variables before
	// we return it up the stack.
	return new Promise(function(resolve, reject) {
		bot.reply(username, message).then(function(reply) {
			// Export user variables to disk.
			userData = bot.getUservars(username);
			fs.writeFile(filename, JSON.stringify(userData, null, 2), function(err) {
				if (err) {
					console.error("Failed to write file", filename, err);
				}
			});

			resolve(reply);
		}).catch(reject);
	})
}
11740
def put(self, request, bot_id, id, format=None):
              
        return super(TelegramBotDetail, self).put(request, bot_id, id, format)
229742
function collationNotSupported(server, cmd) {
  return cmd && cmd.collation && server.ismaster && server.ismaster.maxWireVersion < 5;
}
1366929
def get_bot(self, bot_label):
        
        self.check_bots_ready()
        try:
            return self.bots[bot_label]
        except KeyError:
            message = "No installed bot with label '%s'." % bot_label
            for bot_cls in self.get_bots():
                if bot_cls.name == bot_label:
                    message += " Did you mean '%s'?" % bot_cls.label
                    break
            raise LookupError(message)
1127243
def post(self, request, bot_id, format=None):
        
        return super(EnvironmentVarList, self).post(request, bot_id, format)
790697
def get_robotstxt_parser(url, session=None):
    """"""
    rp = robotparser.RobotFileParser()
    try:
        req = urlopen(url, session, max_content_bytes=MaxContentBytes, raise_for_status=False)
    except Exception:
        # connect or timeout errors are treated as an absent robots.txt
        rp.allow_all = True
    else:
        if req.status_code >= 400:
            rp.allow_all = True
        elif req.status_code == 200:
            rp.parse(req.text.splitlines())
    return rp
715639
function publishRobotsTxt () {
    var path = 'robots.txt';
    return fs
        .statAsync(path)
        .then(function (pStat) {
            if (!pStat.isFile()) {
                // go to our default course of action, that is create robots.txt file
                throw new Error ();
            }
        })
        .catch(Error, function () {
            return fs
                .openAsync(path, 'w')
                .then(function () {
                    return fs.writeFileAsync(path, 'User-agent: *\nSitemap: ' + config.siteUrl + '/sitemap.xml');
                })
                .catch(function (pErr) {
                    log.error(pErr);
                });
        });
}
1350846
def post(self, request, bot_id, format=None):
        
        return super(HookList, self).post(request, bot_id, format)