Wsrtjtyk

I am trying to make a client-server application, where clients register for a request, and get response at a later time.

For fast insertions, I use a defaultdict.

{

    "john":   [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],

    "ram":    [2, 6],

    "bruce":  [1, 4, 5],

    "willam": [7, 1],

}

The only problem this data structure is susceptible to, is "john" who's issuing too many requests, and the server cannot serve other clients fairly in time.

So I thought roundrobin may come to rescue, giving me an iterator that yields clients like this -

"john", 0

"ram", 2

"bruce", 1

"willam", 7

"john", 1

"ram", 6

"bruce", 4

... 

Can anyone please tell me how I can implement such an iterator in an efficient manner?

EDIT: This is what I came up with. Does anyone have a better way to do things?

def roundrobin(requests): 

    remaining = set(requests) 



    index = 0 

    while remaining: 

        up_next = set() 

        for key in remaining: 

            try: 

                print(key, requests[key][index])

            except IndexError: 

                continue 

            up_next.add(key) 

        remaining = up_next 

        index += 1 

It produces the following output

ram 2

john 0

willam 7

bruce 1

bruce 4

ram 6

john 1

willam 1

john 2

bruce 5

john 3

john 4

john 5

john 6

john 7

john 8

john 9

john 10

john 11

john 12

john 13

john 14

john 15

john 16

john 17

john 18

john 19

I don't think it can get any better than this.

def roundrobin2(requests):

    index = 0

    while requests:

        for key in list(requests):

            try:

                key, requests[key][index]

            except IndexError:

                del requests[key]

            else:

                index += 1

You could make a bucket for each requester, and cycle through with itertools.cycle, popping each time.

import itertools



all_requests = {

    "john":   [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19],

    "ram":    [2, 6],

    "bruce":  [1, 4, 5],

    "willam": [7, 1],

}



# handle requests:

for requester in itertools.cycle(all_requests):

    request, all_requests[requester] = all_requests[requester][0], all_requests[requester][1:]

    # Intuitively this seems faster than request = all_requests[requester].pop(0), but I could be wrong

    # you should profile this before using it in production code, or see my note below.



    response = handle_request(request)

    send_response(response)

Note that I'm often pulling from the head of this list, so you should maybe use collections.deque instead which has fast pops and pushes from head or tail.