Hackerrank sorted set solution

client.py

import struct
import socket
import os
import sys


class NetworkHandler():
    def __init__(self, sock):
        self.sock = sock
    def myreceive(self):
        toRet = []
        length = self.receiveUnsInt()
        if length == 0:
            return 0
        for i in range(length):
            toRet.append(self.receiveUnsInt())
        return toRet
    
    def receiveUnsInt(self):
        buf = b''
        while len(buf) < 4:
            buf += self.sock.recv(4)
        num = struct.unpack('!I', buf[:4])[0]
        print("Num received:", num, " buf was:", buf)
        return num
    
    def mysend(self, msg):
        ##build the format string
        lMsg = len(msg)
        fmtStr = "!I"
        for i in range(lMsg):
            fmtStr += "I"
        toSend = [lMsg, *msg]
        print("sending:", toSend)
        self.sock.send(struct.pack(fmtStr, lMsg, *msg))
        
    def disconnect(self):
        self.sock.close()

def main():
    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
    server_address = './socket'
    sock.connect(server_address)
    conn = NetworkHandler(sock)

    with open("test.txt", "r") as f:
        for line in f:
            comm = list(map(int, line.split(" ")))
            conn.mysend(comm)
            print("Received: ", conn.myreceive())

            print("----")

if __name__ == "__main__":
    main()

server.py

from threading import Thread
import queue
import socket
import os
import struct

class MySortedSet():
    """
db = MySortedSet()
db.addScore(10, 5, 346248660)
print(db.dbs)
db.getKeyFromSet(10, 5)
db.addScore(5, 8, 1427404471)
db.addScore(2,1, 1761359496)
db.addScore(2,4, 631790567)
db.getKeyFromSet(2, 4)
db.getKeyFromSet(2, 1)
db.addScore(7,3, 1989599602)
db.getSize(2)
db.removeKeyFromSet(2,1)
db.getSize(2)
db.getRange([2,3,5,7,10], 113558404, 1516732979)
    """
    def __init__(self):
        self.dbs = {}
    def addScore(self, setId, key, value):
        if setId not in self.dbs:
            self.dbs[setId] = dict()
        self.dbs[setId][key] = value
    def removeKeyFromSet(self, setId, key):
        """Remove Key: Removes <key> from <set> if <set> exists and <key> is in <set>."""
        #if setId in self.dbs and key in self.dbs[setId]:
        try:
            del self.dbs[setId][key]
        except:
            pass
    def getSize(self, setId):
        """Get Size: Returns the size of set <set>, or 0 if <set> doesn't exist."""
        if setId in self.dbs:
            return len(self.dbs[setId])
        return 0
    def getKeyFromSet(self, setId, key):
        """Get key-value: Returns the score of key <key> in <set>, and 0 if either the set does not exist or does not contain <key>."""
        
        if setId in self.dbs:
            return self.dbs[setId].get(key,0)
        return 0
    def getRange(self, setIds, lower, upper ):
        """Get Range: Returns all elements in sets <set1> ... <setM> with scores in the range [<lower>, <upper>]. Elements should be returned sorted by non-decreasing order of key. If two keys match, the elements with matching keys should be sorted by non-decreasing order of value."""
        toRet = []
        for setId in setIds:
            if setId in self.dbs:
                for k in self.dbs[setId]:
                    score = self.dbs[setId][k]
                    if lower< score < upper:
                        toRet.append((k,score))
        toSend = []
        for k,v in sorted(toRet):
            toSend += [k,v]
        return toSend

database = MySortedSet()
# NOTE: Use this path to create the UDS Server socket
SERVER_SOCKET_PATH = "./socket";
WORKERS = 8
workQueue = queue.Queue()


class NetworkHandler():
    def __init__(self, sock):
        self.sock = sock
    def myreceive(self):
        toRet = []
        length = self.receiveUnsInt()
        return [self.receiveUnsInt() for i in range(length)]
    
    def receiveUnsInt(self):
        buf = b''
        while len(buf) < 4:
            buf += self.sock.recv(4)
        num = struct.unpack('!I', buf[:4])[0]
        return num
    
    def mysend(self, msg):
        ##build the format string
        lMsg = len(msg)
        fmtStr = "!I"
        message = [lMsg, *msg]
        fmtStr += "I" * lMsg
        print("Going to send:", message )
        self.sock.send(struct.pack(fmtStr, *message))
    def disconnect(self):
        self.sock.close()


class WorkerThread(Thread):
    def __init__(self):
        Thread.__init__(self)
        global database
        self.commands = {}
        self.db = database
        pass
    def run(self):
        global workQueue
        while True:
            sock = workQueue.get()
            self.handler = NetworkHandler(sock)
            self.doWork() 
    def doWork(self):
        commandsList = {1 : self.addScoreCommand, 2 : self.removeKeyCommand,
                   3 : self.getSizeCommand, 4: self.getKeyValueCommand,
                   5: self.getRangeCommand}
        while True:
            message = self.handler.myreceive()
            #print("Received:", message)
            toExecute = commandsList[message[0]]
            if message[0] == 6:
                break
            toExecute(message)
        print("Thanks for playing")
        self.handler.disconnect()
        
    def addScoreCommand(self, message):
        self.db.addScore(message[1], message[2], message[3])
        self.handler.mysend([])
        
    def removeKeyCommand(self, message):
        self.db.removeKeyFromSet(message[1], message[2])
        self.handler.mysend([])
        
    def getSizeCommand(self, message):
        size = self.db.getSize(message[1])
        self.handler.mysend([size])
        
    def getKeyValueCommand(self,message):
        score = self.db.getKeyFromSet(message[1], message[2])
        self.handler.mysend([score])
        
    def getRangeCommand(self,message):
        res = self.db.getRange(message[1:-2], message[-2], message[-1]) 
        self.handler.mysend(res)


def runServer():
    global workQueue, SERVER_SOCKET_PATH
    try:
        os.unlink(SERVER_SOCKET_PATH)
    except OSError:         
        if os.path.exists(SERVER_SOCKET_PATH):
            raise
    sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
    sock.bind(SERVER_SOCKET_PATH)
    sock.listen(8)
    while True:
        clientsocket, address = sock.accept()
        workQueue.put(clientsocket)

def main():
    global WORKERS
    threads = []
    for i in range(WORKERS):
        threads.append(WorkerThread())
    for t in threads:
        t.start()
    runServer()
    
if __name__ == "__main__":
    main()