def facebookBot(request): try: if 'hub.verify_token' in request.GET: if request.GET['hub.verify_token'] == models.Config.get('FacebookVerifyToken'): if 'hub.challenge' in request.GET: return HttpResponse(request.GET['hub.challenge']) return HttpResponse("KO") body = json.loads(request.body) for entry in body['entry']: for message in entry['messaging']: if 'is_echo' not in message and 'message' in message: senderId = message['sender']['id'] client = Wit(access_token=models.Config.get('WitToken'), actions=actions) client.run_actions("session_%s" % senderId, message['message']['text'], {'senderId': senderId}) except Exception, e: traceback.print_exc()
class WitBot(): def __init__(self, witai_key, say_func): actions = { 'say': say_func, 'merge': self.merge, 'error': self.error, 'get_trip': self.get_trip, 'clear_context': self.clear_context, } self._wit_client = Wit(witai_key, actions) self._caldb = CalDbInterface() def chat(self, username, timezone, input_msg, session_id, context={}): if 'messenger_id' not in context: context['messenger_id'] = username if 'timezone' not in context: context['timezone'] = 'America/Los_Angeles' context = self._wit_client.run_actions(session_id, input_msg, context) return context def merge(self, session_id, cxt, entities, msg): logger.info(json.dumps(cxt, indent=4)) for name, vals in entities.items(): if name == 'caltrain_station_start': cxt['start_stop'] = vals[0] elif name == 'caltrain_station_end': cxt['end_stop'] = vals[0] elif name == 'datetime': cxt['stated_time'] = vals[0] return cxt def error(self, session_id, cxt, e): logger.error('Wit.ai error occurred.') raise e def clear_context(self, session_id, cxt): new_cxt = { 'messenger_id': cxt['messenger_id'], 'timezone': cxt['timezone'], } return new_cxt def get_trip(self, session_id, cxt): stated_time = cxt.get('stated_time')['value'] start_stop = cxt.get('start_stop')['value'] end_stop = cxt.get('end_stop')['value'] bullet = cxt.get('bullet') start_stop = station_mapping.get(start_stop) end_stop = station_mapping.get(end_stop) trip = self._caldb.get_trip(start_stop, end_stop, stated_time, bullet) cxt['train_time'] = trip['min_time'] return cxt
def main(arg1): query = arg1 #query=raw_input("Query:") client = Wit(access_token=access_token, actions=actions) #client.interactive() msg = client.run_actions('session1', query, {}) #pprint(msg) #if 'msg' in msg: # print msg['msg'] if 'type' in msg: while msg['type'] != 'stop': if 'msg' not in msg: pass else: print msg['msg'] msg = client.run_actions('test_session', query, {})
def send_message(recipient, text): client = Wit(WITAI_TOKEN, actions) session_id = 'my-user-id-42' context0 = client.run_actions(session_id, text, {}) print(context0) data = { "recipient": {"id": recipient}, "message": {"text": WitAi_returnMessage} } resp = requests.post("https://graph.facebook.com/v2.6/me/messages?access_token=" + ACCESS_TOKEN, json=data) print(resp.content)
class WitAi(object): __ENTITIES_TAG = 'entities' __DEFAULT = None def __init__(self, access_token, actions): self.__wit_client = Wit(access_token, actions) def analyze(self, msg): return self.__wit_client.message(msg) def get_entities(self, msg): return self.__wit_client.message(msg).get(self.__ENTITIES_TAG, self.__DEFAULT) def talk(self, session_id, msg, context): return self.__wit_client.run_actions(session_id, msg, context)
class WitMiddleware(MiddlewareMixin): WIT_DATA_KEY = "_wit" WIT_CONTEXT_KEY = "_context" def __init__(self, *args, **kwargs): from wit import Wit self.access_token = kwargs.pop("access_token", None) self.actions = kwargs.pop("actions", {}) self.client = Wit(access_token=self.access_token, actions=self.actions) super().__init__(*args, **kwargs) def process_request(self, request: BotRequest): if request.text: user_data = request.user_storage.get(request.user_id) wit_data = user_data.get(self.WIT_DATA_KEY, {}) context = wit_data.get(self.WIT_CONTEXT_KEY, {}) result_context = self.client.run_actions(str(request.user_id), request.text, context) wit_data[self.WIT_CONTEXT_KEY] = result_context
def processText(token, text, sessionId, funcs=None, context=None): out = [] def say(session_id, context, msg): out.append(msg) def error(session_id, context, msg): print(u"aiwitutils.processText.error: [{msg}]".format(msg=msg)) pass actions = dict(funcs) if isinstance(funcs, dict) else {} actions["say"] = say actions["error"] = error if "merge" not in actions: actions["merge"] = _mergeDefault client = Wit(token, actions) inCtx = context if context else {} outerCtx = client.run_actions(sessionId, text, inCtx) return (out, outerCtx)
class WitSystem(): def __init__(self): self.owm = OWM(OWM_API, language='ru') actions = { 'send': self.send, 'getForecast': self.get_forecast, 'getExtraForecast': self.get_extra_forecast, 'clearStory': self.clear_story } self.client = Wit(access_token=WIT_TOKEN, actions=actions) self.contexts = {} self.context_answer = {} def first_entity_value(self, entities, entity): if entity not in entities: return None val = entities[entity][0]['value'] if not val: return None return val['value'] if isinstance(val, dict) else val def send(self, request, response): print(response['text'].decode('utf-8')) logger.info('Info "%s" "%s" "%s"' % (response['text'].decode('utf-8'), str(request), str(response))) self.context_answer[request['session_id']] = response def recive(self, chat_id, message, max_steps=DEFAULT_MAX_STEPS): if chat_id not in self.contexts: self.contexts[chat_id] = {} self.contexts[chat_id] = self.client.run_actions(chat_id, message, self.contexts[chat_id], max_steps) return self.context_answer[chat_id] def get_forecast(self, request): context = request['context'] entities = request['entities'] loc = self.first_entity_value(entities, 'location') if loc: observation = self.owm.weather_at_place(loc) w = observation.get_weather() context['forecast'] = w.get_status() context['location'] = loc if context.get('missingLocation') is not None: del context['missingLocation'] else: context['missingLocation'] = True if context.get('forecast') is not None: del context['forecast'] return context def get_extra_forecast(self, request): context = request['context'] entities = request['entities'] location = context['location'] observation = self.owm.weather_at_place(location) w = observation.get_weather() temperature = w.get_temperature(unit='celsius') weather_temp = ' '.join(map(str, (temperature['temp_min'],temperature['temp'],temperature['temp_max']))) humidity = str(w.get_humidity()) context['extraForecast'] = 'В '+ location + ' температура:' +weather_temp + ' влажность:' + humidity return context def clear_story(self, request): context = request['context'] entities = request['entities'] if context.get('missingLocation') is not None: del context['missingLocation'] if context.get('forecast') is not None: del context['forecast'] if context.get('extraForecast') is not None: del context['extraForecast'] return context
from wit import Wit access_token = 'YOUR_ACCESS_TOKEN' def say(session_id, msg): print(msg) def merge(context, entities): return context def error(session_id, msg): print('Oops, I don\'t know what to do.') actions = { 'say': say, 'merge': merge, 'error': error, } client = Wit(access_token, actions) session_id = 'my-user-id-42' client.run_actions(session_id, 'your message', {})
return None val = entities[entity][0]['value'] if not val: return None return val['value'] if isinstance(val, dict) else val def say(session_id, context, msg): print(msg) def merge(session_id, context, entities, msg): # print entities print entities dest = first_entity_value(entities, 'dest') if dest: context['dest'] = dest return context def error(session_id, context, e): print(str(e)) actions = { 'say': say, 'merge': merge, 'error': error } client = Wit(access_token, actions) response = client.run_actions(session_id="xyz",message="I'm planning to go to usa", max_steps=3, context={}) print response
def say(session_id, context, msg): print(msg) def merge(session_id, context, entities, msg): loc = first_entity_value(entities, 'location') if loc: context['loc'] = loc return context def error(session_id, context, e): print(str(e)) def fetch_weather(session_id, context): location = context['loc'] location_id = pywapi.get_loc_id_from_weather_com(location)[0][0] weather_com_result = pywapi.get_weather_from_weather_com(location_id) context['forecast'] = weather_com_result["current_conditions"]["text"] return context actions = { 'say': say, 'merge': merge, 'error': error, 'fetch-weather': fetch_weather, } client = Wit(access_token, actions) session_id = 'YOUR_WIT_USERNAME_HERE' place = raw_input("Enter City Name:") client.run_actions(session_id, 'weather in %s'%place, {})
return None return val['value'] if isinstance(val, dict) else val def say(session_id, context, msg): print(msg) def merge(session_id, context, entities, msg): # print entities print entities dest = first_entity_value(entities, 'dest') if dest: context['dest'] = dest return context def error(session_id, context, e): print(str(e)) actions = {'say': say, 'merge': merge, 'error': error} client = Wit(access_token, actions) response = client.run_actions(session_id="xyz", message="I'm planning to go to usa", max_steps=3, context={}) print response
from wit import Wit # Weather example # See https://wit.ai/patapizza/example-weather access_token = 'YOUR_ACCESS_TOKEN' def say(session_id, msg): print(msg) def merge(context, entities): return context def error(session_id, msg): print('Oops, I don\'t know what to do.') def fetch_forecast(context): context['forecast'] = 'cloudy' return context actions = { 'say': say, 'merge': merge, 'error': error, 'fetch-forecast': fetch_forecast, } client = Wit(access_token, actions) session_id = 'my-user-id-42' client.run_actions(session_id, 'weather in London', {})
del context['joke'] category = first_entity_value(entities, 'category') if category: context['cat'] = category sentiment = first_entity_value(entities, 'sentiment') if sentiment: context['ack'] = 'Glad you liked it.' if sentiment == 'positive' else 'Hmm.' elif 'ack' in context: del context['ack'] return context def error(session_id, context, e): print(str(e)) def select_joke(session_id, context): jokes = all_jokes[context['cat'] or 'default'] shuffle(jokes) context['joke'] = jokes[0] return context actions = { 'say': say, 'merge': merge, 'error': error, 'select-joke': select_joke, } client = Wit(access_token, actions) session_id = 'my-user-id-42' client.run_actions(session_id, 'tell me a joke about tech', {})
new_context['cat'] = category sentiment = first_entity_value(entities, 'sentiment') if sentiment: new_context['ack'] = 'Glad you liked it.' if sentiment == 'positive' else 'Hmm.' elif 'ack' in new_context: del new_context['ack'] return new_context def error(session_id, msg): print('Oops, I don\'t know what to do.') def select_joke(context): new_context = dict(context) jokes = all_jokes[new_context['cat'] or 'default'] shuffle(jokes) new_context['joke'] = jokes[0] return new_context actions = { 'say': say, 'merge': merge, 'error': error, 'select-joke': select_joke, } client = Wit(access_token, actions) session_id = 'my-user-id-42' client.run_actions(session_id, 'tell me a joke about tech', {})
(loc['value'], (date['from'] + datetime.timedelta(days=d)).date().strftime('%B %d, %Y') , weather2string(weather[d])))) if len(weather) < (date['to'].date() - date['from'].date()).days + 1: if len(weather) > 1: say('', {}, 'Sorry, I can only get forecast up to %d days now' % len(weather)) else: say('', {}, 'Sorry, I can only get forecast up to 1 day now') else: say('', {}, ('I cannot get forecast for %s' % loc['value'])) context = {} say(None, None, 'Would you like the forecast for other location?') return context actions = { 'say': say, 'merge': merge, 'error': error, 'get_weather_info': get_weather_info, } if __name__ == '__main__': bot = Wit(access_token, actions) msg = '' context = {} print 'Tip: enter \'end\' to exit..ahihi' while True: msg = raw_input(">> You: ") if msg == 'end': break context = bot.run_actions(session_id, msg, context)
'MyFileOpen': get_fileopen, 'MyFileExecBool': get_fileexecBool, 'MyFileExecList': get_fileexeclist, } client = Wit(access_token="UBTCYTFGDP3K3DJIGRV462NLNG2MM4I7", actions=actions) # # client.interactive() client.logger.setLevel(logging.WARNING) # #resp = client.message('play katy') # print('Yay, got Wit.ai response: ' + str(resp)) # f = open('file.txt') session_id = 'f0607fe6-aa6f-11e6-b121-3417eb627e2d' context = pickle.load(open('context.pkl', "r")) # print context, "in run action" file = open('file.txt', 'r') query = file.read() file.close() context = client.run_actions(session_id, query, context) # context = client.run_actions(session_id, 'yes', context) # print('The session state is now: ' + str(context)) pickle.dump(context, open('context.pkl', 'w')) # print context , "final" #resp = client.converse('my-user-session-42', 'play katy', {}) #print('Yay, got Wit.ai response: ' + str(resp)) #resp = client.converse('my-user-session-42', 'play panjaa', {}) #print('Yay, got Wit.ai response: ' + str(resp)) # def chat_bot( client, context, session_id, query): # context = client.run_actions(session_id, query, context)
if not val: return None return val['value'] if isinstance(val, dict) else val def say(session_id, msg): print(msg) def merge(session_id, context, entities, msg): loc = first_entity_value(entities, 'location') if loc: context['loc'] = loc return context def error(session_id, context, e): print(str(e)) def fetch_weather(session_id, context): context['forecast'] = 'sunny' return context actions = { 'say': say, 'merge': merge, 'error': error, 'fetch-weather': fetch_weather, } client = Wit(access_token, actions) session_id = 'my-user-id-42' client.run_actions(session_id, 'weather in London', {})
def zero_context(session_id, context): context = {} return context def dave_here(session_id, context): say(session_id, context, 'Reached dave_here()') actions = { 'say': say, 'merge': merge, 'error': error, 'fetch-weather': fetch_weather, 'zero_context': zero_context, 'dave_here': dave_here, } client = Wit(access_token, actions) session_id = 'my-user-session-42' context0 = {} context1 = client.run_actions(session_id, 'what is the weather in London?', context0) print('The session state is now: ' + str(context1)) context2 = client.run_actions(session_id, 'and in Brussels?', context1) print('The session state is now: ' + str(context2)) #client.interactive()
class BillyBob: @classmethod def wit_send(cls, request, response): print 'Getting from user... {0}'.format(request) print 'Sending to user... {0}'.format(response['text']) def _post_simple(self, channel, msg): self.slack_client.api_call("chat.postMessage", channel=channel, text=msg, as_user=True) def _post_fmt(self, channel, text, attachments): self.slack_client.api_call("chat.postMessage", channel=channel, text=text, attachments=attachments, as_user=True) @classmethod def _check_intent(cls, intent, key_intent): return intent['entities'] and intent['entities'][key_intent] @classmethod def _fmt_prs(cls, prs, repo): return [{ 'text': '<{0}|{1}>: <{2}|{3}>'.format(p['url'], p['repo_name'], p['pr_url'], p['title']), 'fallback': '{0}: {1}'.format(p['repo_name'], p['title']), 'color': 'warning' } for p in prs[repo]] def wit_get_prs(self, params): chan = params['context']['chan'].encode("ascii", "ignore") print 'requested get_prs ! {0}'.format(params) if self._check_intent(params, 'pull_request'): entities = params['entities']['pull_request'] if len(entities) == 1 and entities[0]['value']: repo = entities[0]['value'] if repo == 'github': prs = fetch_pr.get_prs('github') prs_fmt = self._fmt_prs(prs, 'github') self._post_fmt( chan, 'Here are the open pull requests on Github !', prs_fmt) elif repo == 'bitbucket': prs = fetch_pr.get_prs('bitbucket') prs_fmt = self._fmt_prs(prs, 'bitbucket') self._post_simple( chan, "Sorry bruh I don't know how to do that yet :(") elif repo == 'everywhere': prs = fetch_pr.get_prs('everywhere') prs_fmt_bitbucket = self._fmt_prs(prs, 'bitbucket') prs_fmt_github = self._fmt_prs(prs, 'github') self._post_simple( chan, "You asked for the pull requests on github and bitbucket..." ) if len(prs_fmt_bitbucket) > 0: self._post_fmt(chan, '', prs_fmt_bitbucket) if len(prs_fmt_github) > 0: self._post_fmt(chan, '', prs_fmt_github) else: self._post_simple(chan, 'WTF is that ?') return {} def wit_get_bus_tt(self, params): red_color = "#ff0000" green_color = "#36a64f" chan = params['context']['chan'].encode("ascii", "ignore") buses = sophiabus230.get_next_buses() attachments = [] tz = gettz('Europe/Paris') time_now = datetime.datetime.now(tz=tz) for passage in buses: attachment = {} bus_time = passage['bus_time'] dest = passage['dest'] diff_t = bus_time.replace(tzinfo=tz) - time_now minutes = int(diff_t.total_seconds() / 60) att_str = 'In {0} min (at {1}) towards {2}'.format( minutes, bus_time.strftime("%H:%M"), dest) if passage['is_real_time']: attachment['color'] = red_color else: attachment['color'] = green_color attachment['text'] = att_str attachment['fallback'] = att_str attachments.append(attachment) self._post_fmt(chan, "Here are the next bus passages cowboy !", attachments) return {} def __init__(self, slack_token=None, wit_token=None, **kargs): self.BOT_NAME = 'BillyBob' # TODO: get the BOT_ID at runtime self.BOT_ID = 'U1ZUKEDT4' if slack_token is None: self.slack_token = os.environ['SLACK_API_TOKEN'] else: self.slack_token = slack_token if wit_token is None: self.wit_token = os.environ['WIT_API_TOKEN'] else: self.wit_token = wit_token self._params = kargs if 'wit_actions' in kargs: actions = kargs['wit_actions'] else: actions = { 'send': self.wit_send, 'get_prs': self.wit_get_prs, 'get_bus_tt': self.wit_get_bus_tt } logging.basicConfig(format='%(asctime)s %(levelname)s ' '[%(filename)s:%(lineno)d] %(message)s') self.slack_client = SlackClient(self.slack_token) self.wit_client = Wit(access_token=self.wit_token, actions=actions) def _parse_slack_output(self, slack_rtm_output): at_bot = "<@{0}>".format(self.BOT_ID) output_list = slack_rtm_output if output_list and len(output_list) > 0: for output in output_list: print 'command: {0}'.format(output) if output and 'text' in output and at_bot in output['text']: cmd = output['text'].split(at_bot)[1].strip().lower() chan = output['channel'] print 'detected cmd: {0}'.format(cmd) return cmd, chan return None, None def handle_command(self, command, chan): self.wit_client.run_actions('titoi', command, {'chan': chan}) def start_service(self): print 'Waking up {0}...'.format(self.BOT_NAME) if self.slack_client.rtm_connect(): print '{0} is connected !'.format(self.BOT_NAME) while True: read_payload = self.slack_client.rtm_read() command, chan = self._parse_slack_output(read_payload) if command: self.handle_command(command, chan) time.sleep(1) else: print "Connection failed. Invalid tokens ?"
def converse(msg): client = Wit(WIT_AI_KEY, actions) client.run_actions(session_id, msg)
def merge(session_id, context, entities, msg): loc = first_entity_value(entities, 'location') if loc: context['loc'] = loc return context def error(session_id, context, e): print(str(e)) def fetch_weather(session_id, context): location = context['loc'] location_id = pywapi.get_loc_id_from_weather_com(location)[0][0] weather_com_result = pywapi.get_weather_from_weather_com(location_id) context['forecast'] = weather_com_result["current_conditions"]["text"] return context actions = { 'say': say, 'merge': merge, 'error': error, 'fetch-weather': fetch_weather, } client = Wit(access_token, actions) session_id = 'YOUR_WIT_USERNAME_HERE' place = raw_input("Enter City Name:") client.run_actions(session_id, 'weather in %s' % place, {})
credential = credentials.get("witai", "ServerAccessToken") client = Wit(credential, actions) session_id = 'my-user-id-42' while True: luxes = light.value() luxes = int(luxes) display.setColor(luxes, luxes, luxes) if button.value() is 1: isay("english", "Hi! This is GiekIe! How can I help?") message = recognizeSpeech() display.clear() display.setCursor(0,0) display.write(str(message)) client.run_actions(session_id, message, {}) #updater.idle() ''' luxes = light.value() display.setColor(255, 0, 0) display.setCursor(0,0) display.write('Light ' + str(luxes)) print 'Light ' + str(luxes) time.sleep(1) '''