Port Self-Reference for API Access

[SmirkingKitsune]

I am working on an A1111 extension that uses the GET and POST CuRL commands of A1111's API. Specifically I am using the API to interact with another extension in the A1111 API.

According to the API documentation I should use the default url http://127.0.0.1:7860 for API interactions. However, the problem is that Gradio will increment the port by 1, if the default or subsequent desired ports are unavailable. Meaning if you have another Gradio server running on http://127.0.0.1:7860 then A1111's Gradio server will run on http://127.0.0.1:7861. If you have two other Gradio servers running on ports http://127.0.0.1:7860 and http://127.0.0.1:7861, then A1111's Gradio server will be on http://127.0.0.1:7862. etc. So simply using http://127.0.0.1:7860 for API interactions could break the script if Gradio opens the server on an unexpected port. This can easily be brute forced by incrementally pinging each expected port. However, this brute force solution is wasteful of system resources. I could collect the port from the shared_cmd_options, but that only works if the user manually set the port in the command arguments.

Snippet of brute force identification of the hostname and port:

def get_server_address(): # Brute force method
    # Import the necessary modules
    initialize_util = importlib.import_module('modules.initialize_util')
    shared_cmd_options = importlib.import_module('modules.shared_cmd_options')
    
    # Get server name
    server_name = initialize_util.gradio_server_name()
    if server_name is None:  # Check for invalid value
        server_name = "127.0.0.1"  # Fallback to localhost

    print(f"Server name determined: {server_name}")

    # Determine port
    port = shared_cmd_options.cmd_opts.port
    print(f"Initial port: {port}")
    
    if port is None:
        ports = range(7860, 7870)  # Check 7860 to 7869
        for p in ports:
            url = f"http://{server_name}:{p}/internal/ping"
            try:
                response = requests.get(url, timeout=5)
                if response.status_code == 200:
                    port = p
                    print(f"Found active API on port: {port}")
                    break
            except requests.RequestException as error:
                print(f"API not available on port {p}: {error}")
        if port is None:
            port = 7860  # Default to 7860 if no active port is found
            print(f"No active port found, defaulting to {port}")

    # Return the server address
    return f"http://{server_name}:{port}"

I think I am severely over-complicating this and think there must be an easier way. I suspect I must have missed how I should be doing this when I was rooting around the modules. Can someone tell me how I should be doing this?

[w-e-w]

why don't you just set a static port? --port xxxx

could collect the port from the shared_cmd_options, but that only works if the user manually set the port in the command arguments.

ahh miss that part

---

at the end of the day there is no way of knowing that if a server is running on a specific port of IP address
you'd either have to know that it already exists or ask that if it exists
you can ask "someone" else but that "someone" else would still need to know that someone thing that exists and it can only know by asking or being told
so it's basically in a loop
the issue is gradio uses 7860 by default whitch

add a extra complexity even by reading the command line you can't know the port

if port is specified then it uses that port, but it will fail to Launch if the post is taken
yes I have to happen to me some random process decide to use the out of the way port I decide to for webuo=i

and if environment variable exists
GRADIO_NUM_PORTS=100
GRADIO_SERVER_PORT=10000
the default port will be 10000 and if and if this fails it will try the next part 10001 up to 100 tries

---

it could be possible that you can ask your OS which Port are in use and we used by which process
and you can ask each process ID if they are corresponding to python but now you have to try and figure it out if that python is the actual python you wish

on Windows you can use powersehll to all open ports on and what process is related to
Get-NetTCPConnection
you could try identify whether you are based on the process executable but you only see the python version
but they might be still some ambiguity

---

to be honest I think the best solution is to just ask the user to set a static Port because that's the best solution

this is what everything sane person would when setting up a server for long-term use

[w-e-w]

wait a moment

I am working on an A1111 extension that uses the ......

when you say that so you do you mean that your "extension" as in a python extention that is a part of webui?

if that's the case then it is definitely possible to directly get the IP address of and PORT the server used by web UI internally

I've done this in the past but I need to remember how

but it should be totally possible to avoid the use API in the first place

---

however if you're working on something like external program like a Photoshop extension that connects to webui
then I don't think there is an easy way of getting the port
then yeah asking users to set a static part or you might have to engineer some over complicated solution not ask for system for open ports and resettings from wherever you are Etc which might not even get you the correct port
best to just instruct user to set aesthetic port
the above is assuming that if you're working on the same system
if you are webui remotely then "definitely" ask them to set a static port

[w-e-w]

the way to get the IP/Port of the server
add a callback to on_app_started and read it from demo.local_url
you can reference one of my extension https://github.com/w-e-w/sd-webui-custom-autolaunch/blob/ef4ab1b2e32c7ee8d8934b9ea2cbbf1a761fd686/scripts/custom_autolaunch_command.py#L70-L76

[w-e-w]

but it should be totally possible to avoid the use API in the first place

since you are part of webui you should be able to call the function of that extension internally
completely avoiding the use of API and all the downsides have come with the APIs

[SmirkingKitsune]

Thanks! You are a life saver! I was so troubled by this.

Here is how I updated:

class Script(scripts.Script):
    server_address = None

    @classmethod
    def set_server_address(cls, demo, app, *args, **kwargs):
        cls.server_address = demo.local_url
        print(f"Server address set to: {cls.server_address}")
    
    # Method of getting server address
    @classmethod
    def get_server_address(cls):
        if cls.server_address:
            return cls.server_address
        
        # Fallback to the brute force method if server_address is not set
        print("Server address not set. Falling back to brute force method.")
        
        # Attempting to read server_name and port from initilization
        try:
            # Import the necessary modules
            initialize_util = importlib.import_module('modules.initialize_util')
            shared_cmd_options = importlib.import_module('modules.shared_cmd_options')

            # Get server name and port
            server_name = initialize_util.gradio_server_name()
            if server_name is None or server_name.lower() == "none":  # Check for invalid values
                server_name = f"127.0.0.1"  # Fallback to localhost
            port = getattr(shared_cmd_options.cmd_opts, 'port', None)
            
            # Return the server address
            if port is not None:
                server_url = f"http://{server_name}:{port}"
                response = requests.get(f"{server_url}/internal/ping", timeout=5)
                if response.status_code == 200:
                    return server_url
            print(f"Port returned as: {port}")
        except Exception as error:
            print(f"Could not determine server address: {error}")

        # Fallback method if above fails
        print("Trying fallback ports...")
        ports = range(7860, 7863)
        for port in ports:
            url = f"http://127.0.0.1:{port}"
            try:
                response = requests.get(f"{url}/internal/ping", timeout=5)
                if response.status_code == 200:
                    return url
            except requests.RequestException as error:
                print(f"API not available on port {port}: {error}")

        print("API not found on any port")
        return None
        
        # rest of script

#End of File
script_callbacks.on_app_started(Script.set_server_address)

I'm leaving the brute force as fallback method until I finish thorough testing. Will probably simplify or remove it later, if testing goes well. Initial results indicate that it works great and as expected. Thank you!

[SmirkingKitsune]

but it should be totally possible to avoid the use API in the first place

since you are part of webui you should be able to call the function of that extension internally completely avoiding the use of API and all the downsides have come with the APIs

Yeah, I probably should have directly interacted with the other extensions instead of going through their API. The script I am working on is the batch img2img interrogator script. I am extending the functionality to use more methods of interrogation by utilizing interrogators from other extensions instead of just using the native interrogators. I simply thought it would be easier to make cookie cutter API interactions with multiple extensions, instead of figuring out each interrogator extensions internal naming schemes and methodologies.

[SmirkingKitsune]

You were right, working through the API for a script inside A1111 has more demerits than merits,. I ended up rewriting the script to work directly with the other extensions. I think it improved reliability and functionality, even if it was troublesome to get importlib working properly.