multiple request to webui

[jiyeong08]

I'm making images with python code.
First, I run T2I and then run I2I with the resulting imageof T2I to generate the final image.
The code is modular, and the entire code is written using python-socketio. When the socket client sends a signal to the socket server, the socket server executes the module.
In this part, when the client sends signals multiple times in a row, my webui runs all of the T2I in turn and then I2I in turn. What I want is to run both the T2I and I2I of the first requests, generate the resulting image of the request, and then process the second and third requests.
How can I solve this problem?

The code below is part of the webui module.

        try:
            
            payloadT2I = {
                "prompt": ,
                "negative_prompt": ,
                "seed": ,
                "subseed": ,
                "subseed_strength": ,
                "seed_resize_from_h": ,
                "seed_resize_from_w": ,
                "sampler_name": ,
                "scheduler": ,
                "batch_size": ,
                "steps": ,
                "cfg_scale": ,
                "width": ,
                "height": ,
                "restore_faces": ,
                "eta": ,
                "alwayson_scripts":
            }

            responseT2I = requests.post(url=f"{url}/sdapi/v1/txt2img", json=payloadT2I)
            rT2I = responseT2I.json()

            # final_i2i
            try:
                option_payload1 = {
                    "sd_model_checkpoint": ,
                    "CLIP_stop_at_last_layers": ,
                }
                requests.post(url=f"{url}/sdapi/v1/options", json=option_payload1)
            
                payloadI2I = {
                    "prompt": ,
                    "negative_prompt": ,
                    "steps": ,
                    "seed": ,
                    "subseed": ,
                    "subseed_strength": ,
                    "seed_resize_from_h": ,
                    "seed_resize_from_w": ,
                    "batch_size": ,
                    "sampler_name": ,
                    "scheduler": ,
                    "width": ,
                    "height": ,
                    "cfg_scale": ,
                    "init_images": [rT2I["images"][0]],
                    "denoising_strength": ,
                    "restore_faces": ,
                    "eta": ,
                }

                responseI2I = requests.post(url=f"{url}/sdapi/v1/img2img", json=payloadI2I)
                rI2I = responseI2I.json()

[w-e-w]

I don't see you using any socketio code in the snippet you provided
so I'm going to assume that all you mentioned about modules and socketio is out of scope
and you are sending multiple post request to webui in parallel

WebUI handles request FIFO manner, based on my assumption the server receives multiple txt2img request
after each txt2img finisthed it receives subsequent img2img request
and so it process requests in the requested order

txt2img, txt2img, txt2img, img2img, img2img, img2img
   └────────┼────────┼────────┘        │        │
            └────────┼─────────────────┘        │
                     └──────────────────────────┘

if you want the request to be processed in your txt2img img2img you need to control the order you sent the request
in other words you cannot send all the txt2img requests in parallel

txt2img, img2img, txt2img, img2img, txt2img, img2img
   └────────┘        └────────┘        └────────┘

[jiyeong08]

That code is part of module. When the socket server receives a signal from the client, call this module and run it.
I understood that T2Is are executed first because the queues for T2I are accumulated when the signals come in continuously.
I can't post the whole code here, so maybe I should study the logic of my code on my own. Thank you