UploadFile it's API/type and streaming

[pkucmus]

Hi, a few things.

1. Could the UploadFile.seek also take the whence? So it would conform to the "real" seek type.
2. Since Starlette already relies on AnyIO could it use the anyio.SpooledTemporaryFile instead of relying on it's own UploadFile for async capabilities?
3. Can we have (is this even possible?) an ability to stream the uploaded file?

Where is this coming from:
I have a HTTPX client I'm using to steam a file to a 3rd party service. I appreciate that we have the spooled file but still the entire file needs to go through my ASGI app to be potentially stored on disk for me to read it to stream it forward - let's call this "store and forward". I wonder if there's any chance for me to load a chunk and pass is forward, load next chunk and so on - imagine:

async with request.form() as form:
    filename = form["upload_file"].filename
    
    await client.post(url, content=form["upload_file"].file)

(the content needs to be an AsyncGenerator httpx docs)

Another thing, ignoring the "cut through" upload. My client for that 3rd party service I upload files to can't rely on the UploadFile as sometimes I upload files I download and since the UploadFile is not of the same protocol as let's say the AnyIO Spooled File I would use there, it's (needlessly?) hard to deal with big files in Starlette based apps - that's said I'm not completely sure I'm onto something here.

I guess I'm trying to avoid loading big files, now what is the usual path:

1. File is uploaded
2. We validate it for max size (seek(0, 2); tell())
3. We validate the type with magic bytes (read(8); seek(0))
4. We store it somewhere - would like to stream it to an S3 or anything else, even store on a FS

Less of this is in RAM and less times I need to seek(0) to read the thing the better.

I hope I'm making sense.

[cookesan]

The seek(..., whence=...) request makes sense as a small API improvement. UploadFile.file is file-like, but Starlette's async wrapper only exposes seek(offset) today.

The streaming part is a separate issue. Once you call request.form(), Starlette has parsed the multipart body and produced form fields plus UploadFile objects backed by spooled files. That is not a true cut-through stream to another HTTP client.

If the goal is "receive multipart and stream it directly to HTTPX without buffering each file first", the current high-level UploadFile API is probably too late in the pipeline. You would need to consume request.stream() and use a streaming multipart parser/forwarder, or add a lower-level streaming multipart API. The tradeoff is that once you use the raw stream path, you cannot also rely on Starlette's normal .form() parsing for the same body.