FastAPI HTTP Requests in Streamsync App

[jacob-braun-mn]

Hi all -

Apologies in advance if this is a very 101-level question. I’m a data scientist hoping to use Streamsync to create basic web apps and website POC’s so non-technical users can interact with data and ML models. I have only a basic understanding of web development so Streamsync seems like a fantastic solution.

I’ve been able to design some sites using the builder and am able to track state, update components using state, and perform transformations using event handlers in python functions. What I haven’t been able to figure out yet is how to use the FastAPI functionality to make http requests to external services like model endpoints or external databases. I’ve played around with FastAPI before and know it’s pretty simple to implement when you’re instantiating the FastAPI app in the script (you can just use the decorators like @app.post(“/“), etc.) but I’m not sure how to do this from my main.py script when the app is being generated by streamsync.

I wondered if the solution was to use the custom serving options in the documentation but I’m getting a multi threading error when I try that so figured I’d ask.

Sorry again if this is a silly question and thanks in advance for any guidance!

[SurajRaika]

can you show the code

[jacob-braun-mn]

@SurajRaika Thanks for the response! I don’t have any specific code to share, it’s more of a general question. Basically, my experience with FastAPI is that the script would look something like:

from fastapi import FastAPI

app = FastAPI()

@app.get(“/“)
def someFunction():
    callSomeService()

However, with StreamSync, some script on the backend is automatically creating the FastAPI app so I can’t reference it in my script with the @app.method decorator. Trying to figure out how I could get a handle on the FastAPI app that streamsync creates so I could write those get, post, put, etc. methods using the decorator, and use those functions as the event handler.

[FabienArcellier]

I've been looking for a hook or a way to grab the asgi app from application code. I didn't find any. All the ways I've found involve building your own running endpoint or to run a server inside or above. I don't recommand any of those approach.

Maybe someone will have a great solution without doing it and without changing the streamsync code.

[jacob-braun-mn]

@FabienArcellier Thanks for the response - that’s been my experience as well! It’s the one thing keeping this from being the perfect solution for our data science web apps.

@ramedina86 - Do you know of an approach for this? Appreciate any guidance you can provide!

[FabienArcellier]

Don't use the approach, read #112 (comment)

I share you the the creepy way to do that by creating your own runner. This approach uses so much private methods that it may break at any time. It use internal of fastapi and internal of streamsync. @ramedina86 may have better plan for the future to handle or to not handle this use case.

./runner.py

from os.path import dirname

import uvicorn
from streamsync.serve import get_asgi_app, MAX_WEBSOCKET_MESSAGE_SIZE

asgi_app = get_asgi_app(dirname(__file__), "run")

# Creepy part to change priority of routes
static_route = asgi_app.routes[-1]
asgi_app.router.routes = asgi_app.routes[:-1]


# your endpoint or your app mount should go here
@asgi_app.get('/api/yolo')
async def yolo():
    return {"message": "Hello World"}

# Creepy part to restore static route
asgi_app.router.routes.append(static_route)

uvicorn.run(asgi_app, ws_max_size=MAX_WEBSOCKET_MESSAGE_SIZE)

[ramedina86]

Hello everyone

I think you'd be fine mounting an ASGI server inside another one, as shown on the Custom server documentation. It mounts different Streamsync instances on /app1 and /app2, and returns a Response on /.

Does this cover this requirement? If not, please let me know.

[jacob-braun-mn]

Thanks for the response! I tried that approach initially, but when I try to run the serve.py file, I get the error message below.

`RuntimeError:
        An attempt has been made to start a new process before the
        current process has finished its bootstrapping phase.

        This probably means that you are not using fork to start your
        child processes and you have forgotten to use the proper idiom
        in the main module:

            if name == 'main':
                freeze_support()
                ...

        The "freeze_support()" line can be omitted if the program
        is not going to be frozen to produce an executable.

        To fix this issue, refer to the "Safe importing of main module"
        section in https://docs.python.org/3/library/multiprocessing.html`

[FabienArcellier]

I'm not sure, have you tried putting the code in __name__ == "__main__" ?

import uvicorn
import streamsync.serve
from fastapi import FastAPI, Response

if __name__ == "__main__":
	root_asgi_app = FastAPI()
	sub_asgi_app_1 = streamsync.serve.get_asgi_app("../app1", "run")
	sub_asgi_app_2 = streamsync.serve.get_asgi_app("../app2", "run")

	root_asgi_app.mount("/app1", sub_asgi_app_1)
	root_asgi_app.mount("/app2", sub_asgi_app_2)

	@root_asgi_app.get("/")
	async def init():
	    return Response("""
	    <h1>Welcome to the App Hub</h1>
	    """)

	uvicorn.run(root_asgi_app,
	    host="0.0.0.0",
	    port=5328,
	    log_level="warning",
	    ws_max_size=streamsync.serve.MAX_WEBSOCKET_MESSAGE_SIZE)

They give more explanation in https://stackoverflow.com/a/69515964/2141982. I am not fully sure about what happen but on windows, if you are on window, it may trigger an infinite loop in uvicorn.

[jacob-braun-mn]

@FabienArcellier - Thank you so much for taking the time to help me troubleshoot this. Putting the code inside the__name__ == “__main__” and adding the route lines from your suggesting above works. Interestingly, I get a 404 if I don’t add those lines you refer to as the “Creepy part”. Would mind just explaining what those few lines are doing? Really appreciate all the help!

For reference, the lines I’m referring to are:

static_route = asgi_app.routes[-1]
asgi_app.router.routes = asgi_app.routes[:-1]

And then

asgi_app.router.routes.append(static_route)

I understand that you’re removing the last route from the asgi_app, defining our new FastAPI function, then putting that route back at the end of the routes list, but I can’t quite figure out why that’s necessary.