def connect_to_server(
username, add_users_queue
): # tries : username, username2, username3 ... until server accepts
accepted = False
counter = 1
while not accepted:
to_send = encode(MessageType.addUsername,
username + ("" if counter == 1 else str(counter)))
sock.send(to_send)
received_data = sock.recv(1024)
received_data = list(
map(decode,
received_data.decode('UTF-8').split('$')[:-1]))
for msg in received_data:
msg_type = msg.msg_type
if msg_type == MessageType.usernameTaken:
if _debug:
print("Server didn't accept us, trying other username")
counter += 1
elif msg_type == MessageType.OK:
if _debug: print("Server accepted")
accepted = True
elif msg_type == MessageType.addUsername:
add_users_queue.put(True, msg.sender)
username += "" if counter == 1 else str(counter)
return username
def get_embeddings(model, data):
embeddings = []
for qa_pair in data:
embedding = encode(model=model, text=qa_pair['question'])
embeddings.append(
{'embedding': embedding, 'answers': qa_pair['answers']})
return embeddings
def sendBuffer(client: Client):
client.socket.send(
encode({
"type": "message",
"data": {
"body": client.message_buffer
}
}))
def run(self):
while not self.running_queue.empty():
try:
to_send, receiver = self.message_queue.get(block=True)
to = encode(MessageType.sendMessage, username, to_send,
receiver)
if _debug: print("Sending: " + str(to))
sock.send(to)
except Exception as e:
if _debug: print("Sender Exception: " + str(e))
running_queue.get()
def identityHandler(server, client, message):
new_identity = message["identity"]
client.identity = new_identity
encoded_message = encode({
"type": "success",
"data": {
"body": "Changing identity was successful"
}
})
client.connection.send(encoded_message)
def find_best_match(text):
best_cosine = 0
best_match = None
query_embedding = encode(model, text)
for item in embeddings:
cosine_sim = np.dot(query_embedding, item['embedding'])
if best_cosine < cosine_sim:
best_cosine = cosine_sim
best_match = item
return {'cos_sim': best_cosine, 'best_match': best_match['answers']}
def messageHandler(server, client, message):
body = message["body"]
# Throw an error if the user's packet is malformed
if body == None:
raise MalformedPacketException(
"Malformed packet receved from client")
encoded_message = encode({
"type": "message",
"data": {
"author": client.identity,
"body": body,
"color": client.color.name
}
})
for c in server.clients:
c.connection.send(encoded_message)
def handleConnection(server: Server, client: Client):
# This function will be responsible for handling connections
# once they have actually been aquired
global running
while running:
# Attempt to get a message from the connection
try:
message = decode(client.connection)
msg_type = message.get("type", None)
msg_data = message.get("data", None)
if msg_type == None or msg_data == None:
raise MalformedPacketException(
"Malformed packet receved from client")
if not msg_type in server.handlers:
print("Could not find handler for packet type of {}".format(
msg_type))
continue
handler = server.handlers.get(msg_type)
handler(server, client, msg_data)
except MalformedPacketException:
print("Client with identity {} sent a malformed packet".format(
client.identity))
client.send(
encode({
"type": "error",
"data": {
"body": "A Malformed Packet was sent"
}
}))
except Exception:
# Removing the client from the list of clients
server.clients.remove(client)
print("Lost client with identity {}".format(client.identity))
return
def run(self):
while not self.running_queue.empty():
data = b''
try:
msg = self.messages_to_receive.get(block=True)
if _debug: print(self.username + ": got: " + str(msg))
if msg.msg_type == MessageType.addUsername:
self.clientSocket.send(
encode(MessageType.addUsername, msg.sender,
msg.message, msg.receiver))
elif msg.msg_type == MessageType.removeUsername:
self.clientSocket.send(
encode(MessageType.removeUsername, msg.sender))
elif msg.msg_type == MessageType.sendMessage:
self.clientSocket.send(
encode(MessageType.sendMessage, msg.sender,
msg.message, msg.receiver))
elif msg.msg_type == MessageType.usernameTaken:
self.clientSocket.send(encode(MessageType.usernameTaken))
elif msg.msg_type == MessageType.OK:
self.username = msg.sender
self.clientSocket.send(encode(MessageType.OK))
else:
if _debug: print("Unrecognized message: " + str(msg))
echodata = encode(MessageType.PING)
err = []
for clients in self.server.clients:
try:
clients.send(echodata)
except:
err.append(clients)
self.server.clean_clients(err)
except:
self.server.clean_client(self.clientSocket)
self.running_queue.get()
if _debug: print("EXCEPT clause: {0}".format(data))
break