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 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 __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, 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 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_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, args, datastore):
self.args = args
self.datastore = datastore
self.responder = Responder(args, datastore, self)
if args.use_irc:
self.ircbot = IRCBot(args)
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_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'})
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 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_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
})
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 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 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)
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)
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 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 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"])
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()
from flask import Flask, render_template, jsonify, request
from flask_socketio import SocketIO, send, emit
from flask_sqlalchemy import SQLAlchemy
from responder import Responder
import requests
import json
app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = "postgres://bob3wa:@theai_bob3wa_2020@test-db.czcdgzwouwz1.eu-west-3.rds.amazonaws.com:5433/dbbob3wa"
db = SQLAlchemy(app)
res = Responder()
@app.route('/ask-bob', methods=['POST'])
def respond():
if request.headers['Content-Type'] == 'application/json':
return jsonify(res.detectIntent(request.json, db))
if __name__ == '__main__':
app.run(port=6800, threaded=True)
from responder import Responder
sentry_sdk.init(getenv("SENTRY_DSN"))
logging.basicConfig(
format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
level=logging.INFO)
logger = logging.getLogger(__name__)
gunicorn_logger = logging.getLogger("gunicorn.error")
logger.handlers = gunicorn_logger.handlers
logger.setLevel(gunicorn_logger.level)
app = Flask(__name__)
logger.info("Creating responder...")
responder = Responder(logger)
logger.info("Creating responder... finished")
@app.route("/respond", methods=["POST"])
def respond():
session_id = uuid.uuid4().hex
logger.info(f"Session_id: {session_id}")
dialogs = request.json["dialogs"]
responses = []
confidences = []
for dialog in dialogs:
logger.info(f"User utterance: {dialog['utterances'][-1]['text']}")
logger.info(f"Called intents: {dialog['called_intents']}")
def start_responder(client, server, message):
Responder(client, server, message)
def annotations():
grafana_annotation = json.loads(request.data.decode("utf-8"))
annotation = Annotation(grafana_annotation)
responder = Responder(Responder.get_data_store())
return json.dumps(responder.annotation(annotation)), 200
def test_default_values(self):
responder = Responder()
self.assertEqual(responder.body, {})
self.assertEqual(responder.headers, None)
self.assertEqual(responder.statusCode, 0)
from responder import Responder
from time import sleep
responder = Responder()
responder.default()
while True:
sleep(3)
responder.express("hello1")
sleep(3)
responder.express("hello2")
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 search():
# Liste of named services
responder = Responder(Responder.get_data_store())
return json.dumps(responder.search()), 200
