def get_answer(self, socket): answer_len = socket.myreceive(2) # answer_len = int.from_bytes(answer_len, self.endian) answer_len = struct.unpack('!H', answer_len)[0] Log.log(5, 'answer len is {}'.format(answer_len)) answer = socket.myreceive(answer_len - 2) return answer
class LuisConnect(ActivityHandler): def __init__(self): self.config_reader = ConfigReader() self.configuration = self.config_reader.read_config() self.luis_app_id = self.configuration['LUIS_APP_ID'] self.luis_endpoint_key = self.configuration['LUIS_ENDPOINT_KEY'] self.luis_endpoint = self.configuration['LUIS_ENDPOINT'] self.luis_app = LuisApplication(self.luis_app_id, self.luis_endpoint_key, self.luis_endpoint) self.luis_options = LuisPredictionOptions(include_all_intents=True, include_instance_data=True) self.luis_recognizer = LuisRecognizer( application=self.luis_app, prediction_options=self.luis_options, include_api_results=True) self.log = Log() async def on_message_activity(self, turn_context: TurnContext): info = get_data() luis_result = await self.luis_recognizer.recognize(turn_context) result = luis_result.properties["luisResult"] json_str = json.loads((str(result.entities[0])).replace("'", "\"")) weather = weather_info.get_weather_info(json_str.get('entity')) self.log.write_log(sessionID='session1', log_message="Bot Says: " + str(weather)) await turn_context.send_activity(f"{weather}")
class LuisConnect(ActivityHandler): def __init__(self): self.config_reader = ConfigReader() self.configuration = self.config_reader.read_config() self.luis_app_id = self.configuration['LUIS_APP_ID'] self.luis_endpoint_key = self.configuration['LUIS_ENDPOINT_KEY'] self.luis_endpoint = self.configuration['LUIS_ENDPOINT'] self.luis_app = LuisApplication(self.luis_app_id, self.luis_endpoint_key, self.luis_endpoint) self.luis_options = LuisPredictionOptions(include_all_intents=True, include_instance_data=True) self.luis_recognizer = LuisRecognizer( application=self.luis_app, prediction_options=self.luis_options, include_api_results=True) self.luis_util = LuisUtil() self.log = Log() async def on_message_activity(self, turn_context: TurnContext): #weather_info=WeatherInformation() luis_result = await self.luis_recognizer.recognize(turn_context) result = luis_result.properties["luisResult"] out = self.luis_util.luis_result_as_dict(result) print(out) weather = out['topScoringIntent']['intent'] weather = d[weather] #json_str = json.loads((str("hello")).replace("'", "\"")) #weather=weather_info.get_weather_info(json_str.get('entity')) #weather = "i dont have anaswer" self.log.write_log(sessionID='session1', log_message="Bot Says: " + str(weather)) await turn_context.send_activity(f"{weather}")
def messages(): if "application/jason" in request.headers["content-type"]: log = Log() request_body = request.jason # Activity is basically what user says and what we are sending as a response # they are termed as bot activity. # So the message exchange between the bot and the user is Activity user_says = Activity().deserialize(request_body) # Whatever user has said log.write_log(sessionID="session1", log_message="user says: " + str(user_says)) authorization_header = (request.headers["Authorization"] if "Authorization" in request.headers else "") # Here the 2 new words async and await mean to make the code asyncronous # so that parts of our code doesn't wait for this piece of code to get executed! async def call_user_fun(turncontext): await luis_bot_dialog.turn_on(turncontext) task = loop.create_task( bot_adapter.process_activity(user_says, authorization_header, call_user_fun)) loop.run_until_complete(task) return "" else: return Response(status=406) # status for Not Acceptable
def __init__(self): self.config_reader = ConfigReader() self.configuration = self.config_reader.read_config() self.kb_host = self.configuration['KB_HOST'] self.kb_endpoint = self.configuration['KB_ENDPOINT'] self.kb_route = '' self.log = Log()
def mysend(self, msg): totalsent = 0 while totalsent < len(msg): sent = self.sock.send(msg[totalsent:]) if sent == 0: raise RuntimeError("socket connection broken") totalsent = totalsent + sent Log.log(5, 'sent msg: {}'.format(msg)) return totalsent
def __init__(self): self.config_reader = ConfigReader() self.configuration = self.config_reader.read_config() self.luis_app_id=self.configuration['LUIS_APP_ID'] self.luis_endpoint_key = self.configuration['LUIS_ENDPOINT_KEY'] self.luis_endpoint = self.configuration['LUIS_ENDPOINT'] self.luis_app = LuisApplication(self.luis_app_id,self.luis_endpoint_key,self.luis_endpoint) self.luis_options = LuisPredictionOptions(include_all_intents=True,include_instance_data=True) self.luis_recognizer = LuisRecognizer(application=self.luis_app,prediction_options=self.luis_options,include_api_results=True) self.log=Log()
def __init__(self, port, server_ip, client, timeout=3): self.__port = port Log.log(1, 'pi server thread, port is {}'.format(port)) self.__server_ip = server_ip self.__client = client self.__timeout = timeout self.__socket = MySocket() self.__socket.bind(port) Log.log(0, 'binded on port {}'.format(port)) self.__socket.listen(2) self.__stopped = threading.Event() self.__server_thread = threading.Thread(target=self.main, name='pi_server_t')
def __init__(self, conversation_state: ConversationState, user_state: UserState): self.config_reader = ConfigReader() self.configuration = self.config_reader.read_config() self.luis_app_id = self.configuration['LUIS_APP_ID'] self.luis_endpoint_key = self.configuration['LUIS_ENDPOINT_KEY'] self.luis_endpoint = self.configuration['LUIS_ENDPOINT'] self.luis_app = LuisApplication(self.luis_app_id, self.luis_endpoint_key, self.luis_endpoint) self.luis_options = LuisPredictionOptions(include_all_intents=True, include_instance_data=True) self.luis_recognizer = LuisRecognizer( application=self.luis_app, prediction_options=self.luis_options, include_api_results=True) self.qna_knowledge_base_id = self.configuration["QNA_KNOWLEDGEBASE_ID"] self.qna_endpoint_key = self.configuration["QNA_ENDPOINT_KEY"] self.qna_host = self.configuration["QNA_ENDPOINT_HOST"] self.qna_maker = QnAMaker( QnAMakerEndpoint(knowledge_base_id=self.qna_knowledge_base_id, endpoint_key=self.qna_endpoint_key, host=self.qna_host)) self.log = Log() self.IntentIdentified = False self.intent = 'none' self.stat = 'init' self.city = "" self.score = "" if conversation_state is None: raise TypeError( "[StateManagementBot]: Missing parameter. conversation_state is required but None was given" ) if user_state is None: raise TypeError( "[StateManagementBot]: Missing parameter. user_state is required but None was given" ) self.conversation_state = conversation_state self.user_state = user_state self.conversation_data_accessor = self.conversation_state.create_property( "ConversationData") self.user_profile_accessor = self.user_state.create_property( "UserProfile")
def main(self): while not self.__registered.isSet() and not self.__stopped.isSet(): self.register_on_server() if self.__registered.isSet(): break self.__stopped.wait(self.__timeout) self.__stopped.wait(self.__timeout) while not self.__stopped.is_set(): for device in self.__devices: if type(device) is Thermometer: temp = device.getTemp() Log.log(4, 'temp is {}'.format(temp)) self.send_float_val(device.getKey(), temp) Log.log(1, 'waiting for stop') self.__stopped.wait(self.__timeout)
def messages(): if "application/json" in request.headers["content-type"]: log = Log() request_body = request.json user_says = Activity().deserialize(request_body) log.write_log(sessionID='session1',log_message="user says: "+str(user_says)) authorization_header = (request.headers["Authorization"] if "Authorization" in request.headers else "") async def call_user_fun(turncontext): await luis_bot_dialog.on_turn(turncontext) task = loop.create_task( bot_adapter.process_activity(user_says, authorization_header, call_user_fun) ) loop.run_until_complete(task) return "" else: return Response(status=406) # status for Not Acceptable
def __createDevicesList(self, devs_file_path): with open(devs_file_path, 'r') as devices_file: lines = devices_file.readlines() dev_key = 0 current_line = 0 for line in lines: current_line += 1 try: self.__devices.append(initialize.addDevice(line, dev_key)) dev_key += 1 except KeyError as error: Log.log( 1, 'unresolved device code {} at line {}'.format( error, current_line)) except ValueError as error: Log.log( 1, '{} at line {}: {}'.format(devs_file_path, current_line, error))
class KnowledgeBase(): def __init__(self): self.config_reader = ConfigReader() self.configuration = self.config_reader.read_config() self.kb_host = self.configuration['KB_HOST'] self.kb_endpoint = self.configuration['KB_ENDPOINT'] self.kb_route = '' self.log = Log() def get_answer_from_kb(self, kb_details, question_from_user): self.config_reader = ConfigReader() self.configuration = self.config_reader.read_config() self.kb_route = self.configuration[kb_details] question_to_kb = {} question_to_kb.update({'question': question_from_user}) headers = { 'Authorization': 'EndpointKey ' + self.kb_endpoint, 'Content-Type': 'application/json' } try: self.log.write_log(sessionID='session1', log_message="question " + str(question_to_kb)) self.conn = http.client.HTTPSConnection(self.kb_host, port=443) self.conn.request("POST", self.kb_route, str(question_to_kb), headers) self.response = self.conn.getresponse() self.answer = self.response.read() #this code is written to fetch the actual answer provided by the knowlegemaker answer_in_str = str(json.loads(self.answer)) answer_in_dict = ast.literal_eval(answer_in_str) answer_return = answer_in_dict['answers'][0]['answer'] self.log.write_log(sessionID='session1', log_message="question " + str(answer_return)) return answer_return except: print("Unexpected error:", sys.exc_info()[0]) print("Unexpected error:", sys.exc_info()[1])
class LuisConnect(ActivityHandler): def __init__(self): self.config_reader = ConfigReader() self.configuration = self.config_reader.read_config() self.luis_app_id = self.configuration['LUIS_APP_ID'] self.luis_endpoint_key = self.configuration['LUIS_ENDPOINT_KEY'] self.luis_endpoint = self.configuration['LUIS_ENDPOINT'] self.luis_app = LuisApplication(self.luis_app_id, self.luis_endpoint_key, self.luis_endpoint) self.luis_options = LuisPredictionOptions(include_all_intents=True, include_instance_data=True) self.luis_recognizer = LuisRecognizer(application=self.luis_app, prediction_options=self.luis_options, include_api_results=True) self.log = Log() async def on_message_activity(self, turn_context: TurnContext): knowledgebase = KnowledgeBase() luis_result = await self.luis_recognizer.recognize(turn_context) result = luis_result.properties["luisResult"] top_intent = self.top_intent(luis_result) user_query = turn_context.activity.text kb_answer = knowledgebase.get_answer_from_kb(top_intent, user_query) self.log.write_log(sessionID='session1', log_message="Answer from KB is : " + str(kb_answer)) await turn_context.send_activity(f"{kb_answer}") @staticmethod def top_intent(results: RecognizerResult, default_intent: str = "None", min_score: float = 0.0) -> str: if results is None: raise TypeError("LuisRecognizer.top_intent(): results cannot be None.") top_intent: str = None top_score: float = -1.0 if results.intents: for intent_name, intent_score in results.intents.items(): score = intent_score.score if score > top_score and score >= min_score: top_intent = intent_name top_score = score return top_intent or default_intent
class LuisConnect(ActivityHandler): def __init__(self): self.config_reader = ConfigReader() self.configuration = self.config_reader.read_config() self.luis_app_id=self.configuration['LUIS_APP_ID'] self.luis_endpoint_key = self.configuration['LUIS_ENDPOINT_KEY'] self.luis_endpoint = self.configuration['LUIS_ENDPOINT'] self.luis_app = LuisApplication(self.luis_app_id,self.luis_endpoint_key,self.luis_endpoint) self.luis_options = LuisPredictionOptions(include_all_intents=True,include_instance_data=True) self.luis_recognizer = LuisRecognizer(application=self.luis_app,prediction_options=self.luis_options,include_api_results=True) self.log=Log() async def on_message_activity(self,turn_context:TurnContext): weather_info=WeatherInformation() luis_result = await self.luis_recognizer.recognize(turn_context) result = luis_result.properties["luisResult"] #json_str = json.loads((str(result.entities[0])).replace("'", "\"")) #weather=weather_info.get_weather_info(json_str.get('entity')) #self.log.write_log(sessionID='session1',log_message="Bot Says: "+str(weather)) #await turn_context.send_activity(f"{weather}") check = json.loads((str(result.intents[0])).replace("'", "\"")) if check.get('intent') == 'Welcome': await turn_context.send_activity(f"Hello, I can help you know the weather of any city") #print("Welcome") elif check.get('intent') == 'weather': json_str = json.loads((str(result.entities[0])).replace("'", "\"")) weather=weather_info.get_weather_info(json_str.get('entity')) self.log.write_log(sessionID='session1',log_message="Bot Says: "+str(weather)) await turn_context.send_activity(f"{weather}") else: json_str = json.loads((str(result.entities[0])).replace("'", "\"")) weather=weather_info.get_weather_data(json_str.get('entity')) self.log.write_log(sessionID='session1',log_message="Bot Says: "+str(weather)) await turn_context.send_activity(f"{weather}")
class LuisConnect(ActivityHandler): def __init__(self, conversation_state: ConversationState, user_state: UserState): self.config_reader = ConfigReader() self.configuration = self.config_reader.read_config() self.luis_app_id = self.configuration['LUIS_APP_ID'] self.luis_endpoint_key = self.configuration['LUIS_ENDPOINT_KEY'] self.luis_endpoint = self.configuration['LUIS_ENDPOINT'] self.luis_app = LuisApplication(self.luis_app_id, self.luis_endpoint_key, self.luis_endpoint) self.luis_options = LuisPredictionOptions(include_all_intents=True, include_instance_data=True) self.luis_recognizer = LuisRecognizer( application=self.luis_app, prediction_options=self.luis_options, include_api_results=True) self.qna_knowledge_base_id = self.configuration["QNA_KNOWLEDGEBASE_ID"] self.qna_endpoint_key = self.configuration["QNA_ENDPOINT_KEY"] self.qna_host = self.configuration["QNA_ENDPOINT_HOST"] self.qna_maker = QnAMaker( QnAMakerEndpoint(knowledge_base_id=self.qna_knowledge_base_id, endpoint_key=self.qna_endpoint_key, host=self.qna_host)) self.log = Log() self.IntentIdentified = False self.intent = 'none' self.stat = 'init' self.city = "" self.score = "" if conversation_state is None: raise TypeError( "[StateManagementBot]: Missing parameter. conversation_state is required but None was given" ) if user_state is None: raise TypeError( "[StateManagementBot]: Missing parameter. user_state is required but None was given" ) self.conversation_state = conversation_state self.user_state = user_state self.conversation_data_accessor = self.conversation_state.create_property( "ConversationData") self.user_profile_accessor = self.user_state.create_property( "UserProfile") # session['IntentIdentified']=False # session['state']="init" # session['intent']='none' async def on_turn(self, turn_context: TurnContext): await super().on_turn(turn_context) await self.conversation_state.save_changes(turn_context) await self.user_state.save_changes(turn_context) def welcome(self): return "Hi How can I help you?" async def __send_intro_card(self, turn_context: TurnContext): card = HeroCard( title="Welcome to Bot Framework!", text="Welcome to Welcome Users bot sample! This Introduction card " "is a great way to introduce your Bot to the user and suggest " "some things to get them started. We use this opportunity to " "recommend a few next steps for learning more creating and deploying bots.", images=[CardImage(url="https://aka.ms/bf-welcome-card-image")], buttons=[ CardAction( type=ActionTypes.open_url, title="Get an overview", text="Get an overview", display_text="Get an overview", value= "https://docs.microsoft.com/en-us/azure/bot-service/?view=azure-bot-service-4.0", ), CardAction( type=ActionTypes.open_url, title="Ask a question", text="Ask a question", display_text="Ask a question", value= "https://stackoverflow.com/questions/tagged/botframework", ), CardAction( type=ActionTypes.open_url, title="Learn how to deploy", text="Learn how to deploy", display_text="Learn how to deploy", value= "https://docs.microsoft.com/en-us/azure/bot-service/bot-builder-howto-deploy-azure?view=azure-bot-service-4.0", ), ], ) return await turn_context.send_activity( MessageFactory.attachment(CardFactory.hero_card(card))) def _process_input(self, text: str): color_text = "is the best color, I agree." if text == "red": return f"Red {color_text}" if text == "yellow": return f"Yellow {color_text}" if text == "blue": return f"Blue {color_text}" return "Please select a color from the suggested action choices" async def _send_suggested_actions(self, turn_context: TurnContext): """ Creates and sends an activity with suggested actions to the user. When the user clicks one of the buttons the text value from the "CardAction" will be displayed in the channel just as if the user entered the text. There are multiple "ActionTypes" that may be used for different situations. """ reply = MessageFactory.text("Confirm the option") reply.suggested_actions = SuggestedActions(actions=[ CardAction(title="YES", type=ActionTypes.im_back, value="YES"), CardAction(title="NO", type=ActionTypes.im_back, value="NO"), ]) return await turn_context.send_activity(reply) async def on_message_activity(self, turn_context: TurnContext): # weather_info=WeatherInformation() # print("new session :",session) # Get the state properties from the turn context. user_profile = await self.user_profile_accessor.get( turn_context, UserProfile) conversation_data = await self.conversation_data_accessor.get( turn_context, ConversationData) conversation_data.channel_id = turn_context.activity.channel_id print(conversation_data.channel_id) if user_profile.name is None: # First time around this is undefined, so we will prompt user for name. if conversation_data.prompted_for_user_name: # Set the name to what the user provided. user_profile.name = turn_context.activity.text # Acknowledge that we got their name. await turn_context.send_activity( f"Thanks { user_profile.name }. To see conversation data, type anything in the {conversation_data.channel_id}" ) # Reset the flag to allow the bot to go though the cycle again. conversation_data.prompted_for_user_name = False else: # Prompt the user for their name. await turn_context.send_activity("What is your name?") # Set the flag to true, so we don't prompt in the next turn. conversation_data.prompted_for_user_name = True else: print("1", self.IntentIdentified) print("turn_context", turn_context.activity.text) if self.IntentIdentified == False: luis_result = await self.luis_recognizer.recognize(turn_context ) result = luis_result.properties["luisResult"] print(str(result.intents[0])) intentDetails = json.loads( (str(result.intents[0])).replace("'", "\"")) intent = intentDetails.get('intent') score = intentDetails.get('score') print(intent) print(score) self.IntentIdentified = True self.intent = intent self.score = score if self.intent == "Welcome" and self.score > 0.5: #bot_reply = "Hi How can I help you?" #bot_reply = self.welcome() await self.__send_intro_card(turn_context) bot_reply = f"{ user_profile.name }. To where should i book a flight for you?." self.IntentIdentified = False elif self.intent == "BookFlight" and self.score > 0.5: if self.stat == 'init': print(str(result.entities[0])) json_str = json.loads( (str(result.entities[0])).replace("'", "\"")) #weather=weather_info.get_weather_info(json_str.get('entity')) self.city = json_str.get('entity') bot_reply = "should I book a flight to " + self.city + "." await turn_context.send_activity(f"{bot_reply}") print("1") #await self._send_suggested_actions(turn_context) print("2") text = turn_context.activity.text.lower() print("text", text) #response_text = self._process_input(text) #await turn_context.send_activity(MessageFactory.text(response_text)) self.stat = 'bookFlight' bot_reply = "" return await self._send_suggested_actions(turn_context) elif self.stat == 'bookFlight': if turn_context.activity.text == "YES": bot_reply = "Booked a flight to " + self.city + "." self.stat = 'init' else: bot_reply = "cancelled booking procedure." self.stat = 'init' self.log.write_log(sessionID='session1', log_message="Bot Says: " + str(bot_reply)) self.IntentIdentified = False elif self.score < 0.5: # The actual call to the QnA Maker service. bot_reply = "" self.IntentIdentified = False response = await self.qna_maker.get_answers(turn_context) if response and len(response) > 0: await turn_context.send_activity( MessageFactory.text(response[0].answer)) else: await turn_context.send_activity( "No QnA Maker answers were found.") await turn_context.send_activity(f"{bot_reply}") async def on_members_added_activity(self, members_added: ChannelAccount, turn_context: TurnContext): for member_added in members_added: if member_added.id != turn_context.activity.recipient.id: await turn_context.send_activity("Hello How can I help you!")
def main(self): Log.log(0, 'pi server is working') while not self.__stopped.isSet(): Log.log(3, 'waiting for connection') self.__socket.set_timeout(1) try: connection, address = self.__socket.accept() except Exception as e: Log.log(0, 'exception when accepting connection {}'.format(e)) continue Log.log(1, 'something connected') client_socket = MySocket(connection) msg = client_socket.get_msg() # Log.log(1, 'msg from server: {}'.format(msg)) msg_type = MsgType.to_msg_type(struct.pack('B', msg[2])) if msg_type == MsgType.setState: dev_id = struct.unpack('!H', msg[3:5])[0] state = struct.unpack('!H', msg[5:7])[0] Log.log(2, 'received set state dev={}, state={}'.format(dev_id, state)) device = self.__client.getDevice(dev_id) device.setState(state) else: Log.log(1, 'received bad msg type={} (expected setState)'.format(struct.pack('B', msg[0])))
def send_float_val(self, dev_key, val): socket = MySocket() socket.connect(self.__server_ip, self.__port) Log.log(1, 'connected to server') msg = ValMsg.generate_float_val_msg(val, self.__id, dev_key) try: socket.mysend(msg) answer = self.get_answer(socket) Log.log( 2, 'reveived msg {}, msg type is {}'.format(answer, answer[0])) msg_type = MsgType.to_msg_type(struct.pack('B', answer[0])) if msg_type == MsgType.ack: Log.log(4, 'successfully sent value') elif msg_type == MsgType.nack: Log.log(4, 'Failed to send val') else: Log.log( 3, 'received msg_type {} when expecting ack/nack'.format( msg_type)) raise RuntimeError('unresolved msg_type received') except RuntimeError as e: Log.log( 0, 'Failed to send value {}: {} ... closing connection'.format( val, e)) socket.close()
def sigint_handler(signum, frame): Log.log(0, 'ending by SIGINT') client.stop() pi_server.stop() Log.log(0, 'ending') Log.close() signal.signal(signal.SIGINT, sigint_handler) port = 12345 server_ip = '192.168.1.19' rpi_key = 12 # TODO: rpi_key port and ip from file or other better way devices_path = 'devices.conf' log_filepath = 'logs/file.log' Log.init(log_filepath, 5) Log.log(0, 'server parameters: port = {}, ip = {}'.format(port, server_ip)) # TODO: path from file or something client = Client(devices_path, server_ip, port) pi_server = RpiServer(port + 1, server_ip, client) Log.log(0, 'configured {} devices'.format(len(client.getDevices()))) for dev in client.getDevices(): # Log.log(1, dev.__dict__) Log.log(1, dev.str()) client.start_work() pi_server.start()
#coding:utf-8 import unittest, time from config.config import config from time import sleep from logger.logger import Log log = Log() driver = config.driver class accountManagement(unittest.TestCase): def setUp(self): sleep(2) def tearDown(self): sleep(2) log.info(u"--------测试结束--------") def test001_accountManagement(self): u"""账号管理""" log.info(u"--------测试用例开始--------") driver.find_element_by_link_text(u"权限管理").click() sleep(1) driver.find_element_by_link_text(u"账号管理").click() sleep(1) driver.find_element_by_class_name("textInput").send_keys("txj_testjg1") sleep(1) log.info(u"输入内容:txj_testjg1") driver.find_element_by_class_name("button").click() sleep(2) log.info(u"点击按钮:class = button")
def stop(self): self.__stopped.set() self.__main_thread.join() Log.log(0, 'client main thread joined')
def stop(self): self.__stopped.set() self.__server_thread.join() Log.log(1, 'server pi thread joined')
def get_msg(self): msg_len = self.myreceive(2) unpacked_len = struct.unpack('!H', msg_len)[0] Log.log(3, 'received msg len is {}'.format(unpacked_len)) msg = self.myreceive(unpacked_len - 2) return msg_len + msg
def messages(): if request.method == 'GET': token_sent = request.args.get("hub.verify_token") print("1") if token_sent == 'LUIS': return request.args.get("hub.challenge") print("2") return 'Invalid verification token' elif request.method == 'POST': data = request.get_json() print(data) #if data['channelId'] != 'emulator': if 'object' in data.keys(): if data['object'] == "page": entries = data['entry'] for entry in entries: messaging = entry['messaging'] for messaging_event in messaging: sender = messaging_event['sender']['id'] recipient = messaging_event['recipient']['id'] if messaging_event.get('message'): if messaging_event['message'].get('text'): query = messaging_event['message']['text'] reply = predict.getIntent(query) bot.send_text_message(sender, reply) return "ok", 200 # async def messages(req: Request) -> Response: # if "application/json" in req.headers["Content-Type"]: # body = await req.json() # else: # return Response(status=415) # activity = Activity().deserialize(body) # auth_header = req.headers["Authorization"] if "Authorization" in req.headers else "" # response = await ADAPTER.process_activity(activity, auth_header, luis_bot_dialog.on_turn) # if response: # return json_response(data=response.body, status=response.status) # return Response(status=201) else: if "application/json" in request.headers["content-type"]: log = Log() request_body = request.json print("request_body", request_body) user_says = Activity().deserialize(request_body) print("user_says", user_says) log.write_log(sessionID='session1', log_message="user says: " + str(user_says)) authorization_header = (request.headers["Authorization"] if "Authorization" in request.headers else "") async def call_user_fun(turncontext): await luis_bot_dialog.on_turn(turncontext) task = loop.create_task( bot_adapter.process_activity(user_says, authorization_header, call_user_fun)) loop.run_until_complete(task) return "" else: return Response(status=406) # status for Not Acceptable
def sigint_handler(signum, frame): Log.log(0, 'ending by SIGINT') client.stop() pi_server.stop() Log.log(0, 'ending') Log.close()
def register_on_server(self): socket = MySocket() socket.connect(self.__server_ip, self.__port) Log.log(1, "connected to server") msg = (3).to_bytes(2, self.endian) msg += MsgType.reg.value try: socket.mysend(msg) answer = self.get_answer(socket) Log.log( 2, "received msg {}, msg_type is {}".format(answer, answer[0])) # msg_type = MsgType.to_msg_type(answer[0].to_bytes(1, self.endian)) msg_type = MsgType.to_msg_type(struct.pack('B', answer[0])) if msg_type == MsgType.ack: self.__id = struct.unpack('!H', answer[1:3])[0] Log.log(3, 'received id is {}'.format(self.__id)) elif msg_type == MsgType.nack: raise RuntimeError('nack received, reg refused by server') else: # Log.log(3, 'received msg_type {} when expecting ack'.format(msg_type)) raise RuntimeError( 'unresolved msg_type received {}, expecting ack/nack'. format(msg_type)) for device in self.__devices: msg, length = device.generateMsg() msg = struct.pack( '!H', length + 5) + MsgType.dev.value + struct.pack( '!H', self.__id) + msg socket.mysend(msg) answer = self.get_answer(socket) # msg_type = MsgType.to_msg_type(answer[0].to_bytes(1, self.endian)) msg_type = MsgType.to_msg_type(struct.pack('B', answer[0])) if msg_type == MsgType.ack: dev_id = struct.unpack('!H', answer[1:3])[0] Log.log(3, 'device {} successful sent'.format(dev_id)) elif msg_type == MsgType.nack: dev_id = struct.unpack('!H', answer[1:3])[0] Log.log(3, 'failed to send device {}'.format(dev_id)) else: Log.log( 3, 'received msg_type {} when expecting ack'.format( msg_type)) raise RuntimeError('unresolved msg_type received') msg = struct.pack('!H', 5) + MsgType.end.value + struct.pack( '!H', self.__id) socket.mysend(msg) Log.log(2, 'successfully registered on server') socket.close() self.__registered.set() except RuntimeError as e: Log.log(0, 'registering failed: {} ... closing connection'.format(e)) socket.close()
# try: from .endpoint import Endpoint from .device_types import DevTypeCode from .device_types import DevTypeId from socket import htons import struct from logger.logger import Log GpioEnabled = True try: import RPi.GPIO as gpio except ModuleNotFoundError as e: Log.log(0, 'Failed to import RPi.GPIO: {}'.format(e)) GpioEnabled = False # except SystemError: # from endpoint import Endpoint # from device_types import DevTypeCode # from device_types import DevTypeId class Light(Endpoint): def __init__(self, key, name, pin, zero_triggered=False): super().__init__(key, name) self.__pin = pin self.__zero_triggered = zero_triggered if GpioEnabled: gpio.setmode(gpio.BCM) gpio.setup(pin, gpio.OUT) def turnOn(self): #TODO