Use this method if you want to execute response as simple HTTP request.

        :param bot: Bot instance.
        :return:
320921
async def execute_response(self, bot):
        
        method_name = helper.HelperMode.apply(self.method, helper.HelperMode.snake_case)
        method = getattr(bot, method_name, None)
        if method:
            return await method(**self.cleanup())
        return await bot.request(self.method, self.cleanup())
1333871
def api_request(*args, **kwargs):
        
        r = requests.request(*args, **kwargs)
        return APIResponse(r)
120900
def post(self, request, *args, **kwargs):
        
        input_data = json.loads(request.body.decode('utf-8'))

        if 'text' not in input_data:
            return JsonResponse({
                'text': [
                    'The attribute "text" is required.'
                ]
            }, status=400)

        response = self.chatterbot.get_response(input_data)

        response_data = response.serialize()

        return JsonResponse(response_data, status=200)
22394
def get(self, request, bot_id, id, format=None):
                
        return super(TelegramBotDetail, self).get(request, bot_id, id, format)
1198227
def get_response(self):
        
        user_input = self.usr_input.get()
        self.usr_input.delete(0, tk.END)

        response = self.chatbot.get_response(user_input)

        self.conversation['state'] = 'normal'
        self.conversation.insert(
            tk.END, "Human: " + user_input + "\n" + "ChatBot: " + str(response.text) + "\n"
        )
        self.conversation['state'] = 'disabled'

        time.sleep(0.5)
27193
def process_response(self, request, response):
        
        http_host = request.get_host()

        if http_host and 'herokuapp' in http_host:
            response['X-Robots-Tag'] = 'noindex, nofollow'

        return response
1002624
def get(self, request, bot_id, format=None):
        
        return super(HookList, self).get(request, bot_id, format)
11740
def put(self, request, bot_id, id, format=None):
              
        return super(TelegramBotDetail, self).put(request, bot_id, id, format)
902085
def _request(self, action='GET', url='/', data=None, query_params=None):
        
        if data is None:
            data = {}
        if query_params is None:
            query_params = {}
        response = self.session.request(action, self.api[self.account]['endpoint'] + url,
                                        params=query_params, data=data)
        response.raise_for_status()
        return response
561620
def Execute(self, http):
        

        self._Execute(http)

        for key in self.__request_response_handlers:
            response = self.__request_response_handlers[key].response
            callback = self.__request_response_handlers[key].handler

            exception = None

            if response.status_code >= 300:
                exception = exceptions.HttpError.FromResponse(response)

            if callback is not None:
                callback(response, exception)
            if self.__callback is not None:
                self.__callback(response, exception)
1171048
def _start(self):
        '''

        '''
        if self.whoami is None:
            me = self.get_me()
            if me.get('ok', False):
                self.whoami = me['result']
            else:
                raise ValueError('Bot Cannot request information, check '
                                 'api_key')
771181
def execute_from_url(self, url, input_url):
        '''
        

        '''
        inputs = self._request(input_url)
        resp = self.execute(url, inputs)
        return resp
872467
def get_response(self, action, params, path='/', parent=None,
                     verb='GET', list_marker='Set'):
        
        if not parent:
            parent = self
        response = self.make_request(action, params, path, verb)
        body = response.read()
        boto.log.debug(body)
        if response.status == 200:
            e = boto.jsonresponse.Element(list_marker=list_marker,
                                          pythonize_name=True)
            h = boto.jsonresponse.XmlHandler(e, parent)
            h.parse(body)
            return e
        else:
            boto.log.error('%s %s' % (response.status, response.reason))
            boto.log.error('%s' % body)
            raise self.ResponseError(response.status, response.reason, body)
717119
def get(self, request, bot_id, format=None):
        
        return super(StateList, self).get(request, bot_id, format)
699385
def get_bot_resource(url):
    
    response = None
    response = TrumbaBot_DAO().getURL(url,
                                      {"Content-Type": "application/xml"})
    _log_xml_resp("Bothell", url, response)
    return response
525432
def post(self, request, bot_id, format=None):
        
        return super(TelegramChatStateList, self).post(request, bot_id, format)
107424
private static BotMillNetworkResponse postInternal(String url,
			StringEntity input) {
		BotMillNetworkResponse response = NetworkUtils.post(url, input);
		propagateResponse(response);
		return response;
	}