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 __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 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 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)
