I'm not able to stream the chunks from in_memory_file from google cloud storage bucket

PYTHON This is the Python code, We are streaming our large file from google cloud storage to cloud run. In this code the large csv file is splitting into chunks and those chunks are going into in_memory_file whenever we got the first chunks it should immediately start streaming it and the remaining chunks will stream in response but we are not able to stream those chunks from in_memory_file

import os
import signal
import sys
import json
import pandas as pd
import structlog
import time
import threading
import io
import csv

from concurrent.futures import ProcessPoolExecutor
from concurrent.futures import ThreadPoolExecutor
from types import FrameType
from io import BytesIO, StringIO
from google.cloud import storage
from google.oauth2 import service_account
from flask import Flask, Response, request

app = Flask(__name__)

# SigTerm Log
def getJSONLogger() -> structlog._config.BoundLoggerLazyProxy:
    structlog.configure(
        processors=[`enter code here`
            structlog.stdlib.add_log_level,
            structlog.stdlib.PositionalArgumentsFormatter(),
            structlog.processors.TimeStamper("iso"),
            structlog.processors.JSONRenderer(),
        ],
        wrapper_class=structlog.stdlib.BoundLogger,
    )
    return structlog.get_logger()

logger = getJSONLogger()

# SigTerm Handler
def shutdown_handler(signal: int, frame: FrameType) -> None:
    logger.info("Signal received, safely shutting down.")
    print("Exiting process.", flush=True)
    sys.exit(0)
    signal.signal(signal.SIGTERM, shutdown_handler)

# Split files to chunks
def split_byte_size(size: int, uri: str, bucket: str, key: str) -> list:
    byte_list = []
    chunks = 50
    start = 0
    for i in range(size, size * chunks + 1, size):
        stop = i // chunks
        byte_list.append({"uri": uri, "start": start, "end": stop, "bucket": bucket, "key": key})       
        start = stop + 1
    return byte_list

#Cloud Storage connection
project = 'XYZ'
service_account_credentials_path = 'key.json'
credentials = service_account.Credentials.from_service_account_file(service_account_credentials_path) 
storage_client = storage.Client(project=project, credentials=credentials)

# Download objects as chunks
def downloader(input: dict) -> object:
    bucket_object = storage_client.get_bucket(bucket_or_name=input["bucket"])
    blob = bucket_object.blob(input["key"])
    in_memory_file = io.BytesIO()
    blob.download_to_file(in_memory_file, start=input['start'], end=input['end'])
    #print("Chunk " + str(input['start']) + " to " + str(input['end']) + "completed")
    return in_memory_file

@app.route("/chunk_data")
def chunk_data():
    bucket_name = 'cloudrundemofile'
    source_blob_name = 'demofile.csv'
    
    bucket_object = storage_client.get_bucket(bucket_name)
    blob = bucket_object.get_blob(source_blob_name)
    split_bytes = split_byte_size(blob.size, project, bucket_name, source_blob_name)
    print(split_bytes)

    #Async Thread
    with ThreadPoolExecutor(max_workers=5) as ex:
        results = ex.map(downloader, split_bytes)
        resp = Response(results, 206, mimetype='text/csv')
    #resp.headers.add('Content-Range', 'bytes {0}-{1}/{2}'.format(start, start + length - 1, file_size))
    return resp
    #return "Success"

if __name__ == "__main__":
    signal.signal(signal.SIGINT, shutdown_handler)
    app.run(host="0.0.0.0", port=8080)
else:
    signal.signal(signal.SIGTERM, shutdown_handler)**