def __init__(self, dht_addr): my_addr = dht_addr my_id = identifier.RandomId() my_node = Node(my_addr, my_id) tracker_ = tracker.Tracker() token_m = token_manager.TokenManager() self.reactor = ThreadedReactor() rpc_m = RPCManager(self.reactor, my_addr[1]) querier_ = Querier(rpc_m, my_id) routing_m = RoutingManager(my_node, querier_, bootstrap_nodes) responder_ = Responder(my_id, routing_m, tracker_, token_m) responder_.set_on_query_received_callback(routing_m.on_query_received) querier_.set_on_response_received_callback( routing_m.on_response_received) querier_.set_on_error_received_callback(routing_m.on_error_received) querier_.set_on_timeout_callback(routing_m.on_timeout) querier_.set_on_nodes_found_callback(routing_m.on_nodes_found) routing_m.do_bootstrap() rpc_m.add_msg_callback(QUERY, responder_.on_query_received) self.lookup_m = LookupManager(my_id, querier_, routing_m) self._routing_m = routing_m
def shorten(event, context): if event['body'] == None or event['body'] is None: logging.warning("Validation Failed") return Responder(statusCode=400, body={ 'error': 'missing body' }).respond() data = json.loads(event['body']) if 'url' not in data: logging.warning("Validation Failed") return Responder(statusCode=400, body={ 'error': 'url is required' }).respond() domain_name = event['requestContext']['domainName'] path = event['requestContext']['path'] item = UrlMapper().create_url_map_item(long_url=data['url'], domain_name=domain_name, path=path) DynamoWrapper().create_url_item(item=item) body = { 'shortUrl': item['short_url'], } return Responder(statusCode=200, body=body).respond()
def __init__(self, dht_addr): my_addr = dht_addr my_id = identifier.RandomId() my_node = Node(my_addr, my_id) tracker_ = tracker.Tracker() token_m = token_manager.TokenManager() self.reactor = ThreadedReactor() rpc_m = RPCManager(self.reactor, my_addr[1]) querier_ = Querier(rpc_m, my_id) routing_m = RoutingManager(my_node, querier_, bootstrap_nodes) responder_ = Responder(my_id, routing_m, tracker_, token_m) responder_.set_on_query_received_callback( routing_m.on_query_received) querier_.set_on_response_received_callback( routing_m.on_response_received) querier_.set_on_error_received_callback( routing_m.on_error_received) querier_.set_on_timeout_callback(routing_m.on_timeout) querier_.set_on_nodes_found_callback(routing_m.on_nodes_found) routing_m.do_bootstrap() rpc_m.add_msg_callback(QUERY, responder_.on_query_received) self.lookup_m = LookupManager(my_id, querier_, routing_m) self._routing_m = routing_m
def runIters(procNum): ITERATIONS = 100 guessesToWin = [] losses = 0 for i in range(ITERATIONS): guesser = Guesser() guesser.weightingTuple = weightTuple responder = Responder( getCellTuple(n2l(random.randint(1, 18)), random.randint(1, 18))) # print(f"Iteration {i}: {formatCell(responder.cell)}") turns = 0 gameOver = False while not gameOver: guess = guesser.getGuess() # print(f"Turn {turns} of iteration {i}: {formatCell(guess[0])}") if guess[1]: if responder.checkSolve(guess[0]): guessesToWin.append(turns) break else: losses += 1 break guesser.feedback(guess[0], responder.check(guess[0])) turns += 1 return (guessesToWin, losses, ITERATIONS)
def __init__(self, args, datastore): self.args = args self.datastore = datastore self.responder = Responder(args, datastore, self) if args.use_irc: self.ircbot = IRCBot(args)
def __init__(self, dht_addr): self.my_addr = dht_addr self.my_id = identifier.RandomId() self.my_node = Node(self.my_addr, self.my_id) self.tracker = tracker.Tracker() self.token_m = token_manager.TokenManager() self.reactor = ThreadedReactor() self.rpc_m = RPCManager(self.reactor, self.my_addr[1]) self.querier = Querier(self.rpc_m, self.my_id) self.routing_m = RoutingManager(self.my_node, self.querier, bootstrap_nodes) self.responder = Responder(self.my_id, self.routing_m, self.tracker, self.token_m) self.responder.set_on_query_received_callback( self.routing_m.on_query_received) self.querier.set_on_response_received_callback( self.routing_m.on_response_received) self.querier.set_on_error_received_callback( self.routing_m.on_error_received) self.querier.set_on_timeout_callback(self.routing_m.on_timeout) self.querier.set_on_nodes_found_callback(self.routing_m.on_nodes_found) self.routing_m.do_bootstrap() self.rpc_m.add_msg_callback(QUERY, self.responder.on_query_received) self.lookup_m = LookupManager(self.my_id, self.querier, self.routing_m)
def __init__(self): Responder.__init__(self) self.numStates = 71 self.numActions = 71 tf.reset_default_graph() # Set learning parameters learningRate = 0.1 self.action = 0 self.currentState = 0 self.y = .99 self.e = 0.1 self.numResets = 0 self.resetCalled = False self.learn = self.runNet() #These lines establish the feed-forward part of the network used to choose actions self.inputs1 = tf.placeholder(shape=[1, self.numStates], dtype=tf.float32) self.W = tf.Variable( tf.random_uniform([self.numStates, self.numActions], 0, 0.01)) self.Qout = tf.matmul(self.inputs1, self.W) self.predict = tf.argmax(self.Qout, 1) #Below we obtain the loss by taking the sum of squares difference between the target and prediction Q values. self.nextQ = tf.placeholder(shape=[1, self.numActions], dtype=tf.float32) self.loss = tf.reduce_sum(tf.square(self.nextQ - self.Qout)) self.trainer = tf.train.GradientDescentOptimizer( learning_rate=learningRate) self.updateModel = self.trainer.minimize(self.loss) self.init = tf.global_variables_initializer( ) #tf.initialize_all_variables()
def query(): grafana_query = json.loads(request.data.decode("utf-8")) g_query = Query(grafana_query) responder = Responder(Responder.get_data_store()) resp = responder.query(g_query) return (json.dumps(resp), 200) if resp else flask.abort(500)
def test_responder_hands_what_it_got_from_receive_to_handler(self): self.transmitter.receive = mock.MagicMock(return_value="for the handler") handler = ResponseHandler(MoveGenerator()) handler.response = mock.Mock() responder = Responder(self.transmitter,handler) responder.respond() handler.response.assert_called_with("for the handler")
def __init__(self): Responder.__init__(self) self.batch_size = 50 self.gamma = 0.99 self.update_frequency = 5 self.learningRate = 0.1 self.createGraph()
def test_rappor(): responder = Responder() reviewer = Reviewer() num_responders = 1000 num_choices = 20 real_responses = [0] * num_choices random_responses = [0] * num_choices real_responses_per = [0] * num_choices estimated_responses_per = [0] * num_choices total_random = 0 print("") for x in range(num_responders): real_value = int(round(normalvariate(10, 1), 0)) real_value = min(num_choices - 1, real_value) real_value = max(0, real_value) real_responses[real_value] += 1 response = responder._generate_response(num_choices, real_value) for y in range(num_choices): random_responses[y] += response[y] estimated_responses = reviewer._estimate_responses(random_responses, num_responders) for y in range(num_choices): real_responses_per[y] = round(real_responses[y] / num_responders, 4) * 100 estimated_responses_per[y] = estimated_responses[y] * 100 print(["{0:0.2f}".format(i) for i in real_responses_per]) print(["{0:0.2f}".format(i) for i in estimated_responses_per]) assert (True)
def __init__(self): Responder.__init__(self) #we are using a trained model, no need to train further or to save or display results self.recordRewards = False self.plotResults = False self.useTensorBoard = False self.saveModels = False self.loadModels = True
def test_responder_hands_what_it_got_from_receive_to_handler(self): self.transmitter.receive = mock.MagicMock( return_value="for the handler") handler = ResponseHandler(MoveGenerator()) handler.response = mock.Mock() responder = Responder(self.transmitter, handler) responder.respond() handler.response.assert_called_with("for the handler")
def test_returns_board_with_obvious_move(self): transmitter = mock.Mock() transmitter.receive = mock.MagicMock(return_value=self.easy_win_possible) generator = MoveGenerator() handler = ResponseHandler(generator) responder = Responder(transmitter,handler) responder.respond() transmitter.send.called_with( {"winner_after_ai_move":"o","ai_move":3} )
def test_redirect_with_headers(self): responder = Responder(statusCode=302, body='http://test.com', headers={'test': 'val'}) response = responder.respond() self.assertEqual(response['statusCode'], 302) self.assertEqual(response['body'], 'http://test.com') self.assertEqual(response['headers'], {'test': 'val'})
def __init__(self): Responder.__init__(self) self.batch_size = 1 self.gamma = 0.99 self.numRewardsForUpdate = 1 self.learningRate = 0.03 self.numHiddenNeurons = 1 self.createGraph()
def test_returns_board_with_obvious_move(self): transmitter = mock.Mock() transmitter.receive = mock.MagicMock( return_value=self.easy_win_possible) generator = MoveGenerator() handler = ResponseHandler(generator) responder = Responder(transmitter, handler) responder.respond() transmitter.send.called_with({ "winner_after_ai_move": "o", "ai_move": 3 })
def test_integration_of_parts(self): DUMB_AI_DEPTH = 1 data_from_transmitter_receive = {"board":{1:"x", 2:"x"}, "depth":DUMB_AI_DEPTH} SMART_MOVE = 3 transmitter = mock.Mock() transmitter.receive = mock.MagicMock(return_value=data_from_transmitter_receive) handler = ResponseHandler(MoveGenerator()) responder = Responder(transmitter,handler) responder.respond() self.assertNotEqual(SMART_MOVE, transmitter.send.call_args[0][0]["ai_move"]) self.assertEqual(None, transmitter.send.call_args[0][0]["winner_after_ai_move"])
def test_response_no_headers(self): responder = Responder(statusCode=200, body={'url': 'http://test.com'}) response = responder.respond() self.assertEqual(200, response['statusCode']) self.assertEqual('{"url": "http://test.com"}', response['body']) # expect 'headers' not in response dict error = False try: response['headers'] except: error = True self.assertEqual(error, True)
def redirect(event, context): pathParams = event['pathParameters'] data = DynamoWrapper().get_item(pathParams['id']) if 'Item' not in data: logging.warn("Short URL Not Found") return Responder(statusCode=404) destination = data['Item']['long_url'] headers = {'Location': destination, 'Content-Type': 'text/plain'} return Responder(statusCode=302, body=destination, headers=headers).respond()
def test_it_hooks_into_socket_sends_and_receives(self): transmitter = JsonTransmitter(self.connection_socket) handler = ResponseHandler(MoveGenerator()) responder = Responder(transmitter, handler) game_info = json.dumps({"board": {1: "o", 3: "o"}, "depth": 20}) self.sock.send(game_info) responder.respond() data_received = self.sock.recv(1024) updated_game = json.loads(data_received) WIN_MOVE = 2 self.assertEqual(WIN_MOVE, updated_game["ai_move"]) self.assertEqual("o", updated_game["winner_after_ai_move"]) self.assertEqual(None, updated_game["winner_on_board"])
def test_it_hooks_into_socket_sends_and_receives(self): transmitter = JsonTransmitter(self.connection_socket) handler = ResponseHandler(MoveGenerator()) responder = Responder(transmitter,handler) game_info = json.dumps({ "board": {1:"o",3:"o"}, "depth": 20 }) self.sock.send(game_info) responder.respond() data_received = self.sock.recv(1024) updated_game = json.loads(data_received) WIN_MOVE = 2 self.assertEqual(WIN_MOVE, updated_game["ai_move"]) self.assertEqual("o" ,updated_game["winner_after_ai_move"]) self.assertEqual(None, updated_game["winner_on_board"])
class IOHandler(): def __init__(self, args, datastore): self.args = args self.datastore = datastore self.responder = Responder(args, datastore, self) if args.use_irc: self.ircbot = IRCBot(args) def get_message(self) -> str: '''Returns the next message from the user''' if self.args.use_irc: return self.ircbot.get_message() return input("> ") def send_message(self, message: str) -> None: '''Sends a message to the user''' if self.args.use_irc: return self.ircbot.send_message(message) print(f"{self.args.bot_name}: {message}\n") def ask_question(self, question: str) -> str: '''Prompts the user with question, returns their response''' self.send_message(question) return self.get_message() def listen(self) -> None: '''Main loop of the chatbot. Gets messages, prints response. Returns when program is over''' while True: try: message = self.get_message() #Exit condition if self.responder.is_signaling_exit(message): self.send_message(self.responder.get_exit_phrase()) return self.send_message(self.responder.get_response(message)) except KeyboardInterrupt: self.send_message(self.responder.get_exit_phrase()) break
class Controller: def __init__(self, dht_addr): self.my_addr = dht_addr self.my_id = identifier.RandomId() self.my_node = Node(self.my_addr, self.my_id) self.tracker = tracker.Tracker() self.token_m = token_manager.TokenManager() self.reactor = ThreadedReactor() self.rpc_m = RPCManager(self.reactor, self.my_addr[1]) self.querier = Querier(self.rpc_m, self.my_id) self.routing_m = RoutingManager(self.my_node, self.querier, bootstrap_nodes) self.responder = Responder(self.my_id, self.routing_m, self.tracker, self.token_m) self.responder.set_on_query_received_callback( self.routing_m.on_query_received) self.querier.set_on_response_received_callback( self.routing_m.on_response_received) self.querier.set_on_error_received_callback( self.routing_m.on_error_received) self.querier.set_on_timeout_callback(self.routing_m.on_timeout) self.querier.set_on_nodes_found_callback(self.routing_m.on_nodes_found) self.routing_m.do_bootstrap() self.rpc_m.add_msg_callback(QUERY, self.responder.on_query_received) self.lookup_m = LookupManager(self.my_id, self.querier, self.routing_m) def start(self): self.reactor.start() def stop(self): #TODO2: stop each manager self.reactor.stop() def get_peers(self, info_hash, callback_f, bt_port=None): return self.lookup_m.get_peers(info_hash, callback_f, bt_port)
class ResponderTest(unittest.TestCase): sender = Sender(bot=bot) responder = Responder(sender=sender) def test_respond(self): logger.log(self.responder) answer = Answer() answer.create_reply_keyboard(keyboard=[['hello']], is_one_time=True, is_selective=True)
def handle(): config: ReferralBotConfig = ReferralBotConfig('referralbot.ini') print("Starting...") logging.info("[Info] Starting bot in {type} mode...".format( type=config.referral_source_type)) while True: print("Checking inbox...") try: for message in reddit.inbox.unread(limit=None): if isinstance(message, Message): responder = Responder(reddit, config, message) responder.run() message.mark_read() time.sleep(30) except ReferralBotFatalException: print( "FATAL error occurred. Here's the traceback: \n {} \n\n Exiting!" .format(traceback.format_exc())) logging.fatal( "[FATAL] {msg}".format(msg=format(traceback.format_exc()))) logging.fatal("[FATAL] Bot is terminating") exit(1) except RedditAPIException: # probably rate limited. Sleep for a minute print( "Error occurred. Here's the traceback: \n {} \n\n Sleeping...". format(traceback.format_exc())) logging.warning( "[Warning] Error occurred. Stacktrace follows: \n {}".format( traceback.format_exc())) time.sleep(60) except Exception: print( "Error occurred. Here's the traceback: \n {} \n\n Sleeping...". format(traceback.format_exc())) logging.warning( "[Warning] Error checking inbox. Stacktrace follows: \n {}". format(traceback.format_exc())) time.sleep(30)
def setUp(self) -> None: self.ds = Mock() self.ds.get_app_data.return_value = [ ('the app', datetime.datetime(2020, 1, 1, 4), 'fu'), ('the app', datetime.datetime(2020, 1, 1, 4), 'fu'), ('the app', datetime.datetime(2020, 1, 1, 4), 'fu'), ('the app', datetime.datetime(2020, 1, 1, 4), 'fu'), ('the app', datetime.datetime(2020, 1, 1, 4), 'fu') ] self.ds.get_data_series_var.return_value = None self.responder = Responder(self.ds)
def test_integration_of_parts(self): DUMB_AI_DEPTH = 1 data_from_transmitter_receive = { "board": { 1: "x", 2: "x" }, "depth": DUMB_AI_DEPTH } SMART_MOVE = 3 transmitter = mock.Mock() transmitter.receive = mock.MagicMock( return_value=data_from_transmitter_receive) handler = ResponseHandler(MoveGenerator()) responder = Responder(transmitter, handler) responder.respond() self.assertNotEqual(SMART_MOVE, transmitter.send.call_args[0][0]["ai_move"]) self.assertEqual( None, transmitter.send.call_args[0][0]["winner_after_ai_move"])
class JiakBot: # Read in the config in the auth files # config_file_path = 'D:/Workspace-Github/saproject/code/99_bot/jiakbot/config_app/app_config.ini' # config_key = 'yangcheng' config_file_path = '/Users/junquantham/Development/saproject/code/bot/jiakbot/config_app/app_config.ini' config_key = 'file_path' config = configparser.ConfigParser() config.read(config_file_path) jiakbot_parser = JiakBotParser(config, config_key) state_machine = StateMachine(config, config_key) responder = Responder(config, config_key) # Initializer def __init__(self): pass # Public function to respond # ----------------------------------------------------- def respond(self, sentence, uid=None): p = self.jiakbot_parser sm = self.state_machine r = self.responder response = '' print('----- DEBUGGING -----') # get the parsed dict parsed_dict = p.parse_input(sentence) # get the current state sm.update_state(parsed_dict) # get the response response = r.get_response(parsed_dict, sm.state, sm.context, sm.history, uid) if sm.state != r.state_after_response: sm.update_state_after_response(r.state_after_response) print('parsed_dict:', parsed_dict) print('state:', sm.state) print('context', sm.context) print('----- ----- ----- -----') return (response)
def setUp(self) -> None: j_data = json.dumps({'inner': {'fu': 'bar', 'bar': 2}, 'outer': 123.4}) self.ds = Mock() self.ds.get_app_data.return_value = [ ('the app', datetime.datetime(2020, 1, 1, 4), j_data), ('the app', datetime.datetime(2020, 1, 1, 4), j_data), ('the app', datetime.datetime(2020, 1, 1, 4), j_data), ('the app', datetime.datetime(2020, 1, 1, 4), j_data), ('the app', datetime.datetime(2020, 1, 1, 4), j_data) ] self.responder = Responder(self.ds)
def start_responder(client, server, message): """ Creates a new responder instance. Parameters ---------- `client : dict` Client from WebSocket Server API `server : WebsocketServer` Server from WebSocket Server API `message : str` Client's message """ Responder(client, server, message)
async def run(): rep = Responder() # load azure credentials f = open('azure-credentials/config.json') azureConfig = json.load(f) f.close() @sio.event def connect(): print('connection established') @sio.on('ask-bob') async def on_message(msg): await sio.emit('bob-msg', rep.detectIntent(msg)) @sio.event def disconnect(): print('disconnected from server') await sio.connect('https://localhost:5000') await sio.wait() sio.disconnect() rep.close()
def setUp(self) -> None: self.ds = Mock() self.ds.get_app_data.return_value = [ ('the app', datetime.datetime(2020, 1, 1, 4), '{"a": {"b": "val"} }'), ('the app', datetime.datetime(2020, 1, 1, 4), '{"a": {"b": "val"} }'), ('the app', datetime.datetime(2020, 1, 1, 4), '{"a": {"b": "val"} }'), ('the app', datetime.datetime(2020, 1, 1, 4), '{"a": {"b": "val"} }'), ('the app', datetime.datetime(2020, 1, 1, 4), '{"a": {"b": "val"} }') ] self.ds.get_data_series_var.return_value = 'a.b' self.responder = Responder(self.ds)
from datetime import datetime import wit import pyaudio import pvporcupine from gtts import gTTS from logmmse import logmmse_from_file from mpyg321.mpyg321 import MPyg321Player from responder import Responder KEYWORDS = ["jarvis", "bumblebee"] rp = Responder() pa = pyaudio.PyAudio() pl = MPyg321Player() ai = wit.Wit(os.getenv("WITAI_TOKEN")) porcupine = pvporcupine.create(keywords=KEYWORDS) sample_rate = porcupine.sample_rate frames_per_buffer = porcupine.frame_length DURATION = 4.5 audio_stream = pa.open( rate=sample_rate, channels=1, format=pyaudio.paInt16, input=True, frames_per_buffer=frames_per_buffer,
def test_responder_sends_what_it_got_from_handler(self): handler = ResponseHandler(mock.Mock()) handler.response = mock.MagicMock(return_value="some stuff") responder = Responder(self.transmitter, handler) responder.respond() self.transmitter.send.assert_called_with("some stuff")
def __init__(self): Responder.__init__(self)