Architecture :
1. File transfer invoicing API
2. Compression of file/files which would be sent over internet
3. Acknowledgement API for compression status
4. Document transfer protocol from browser client to server
5. Sending compressed file in response :)

File Transfer Invoicing API :
Whenever user want to download the file, first we should initiate compression of files and then transfer compressed file to consume less internet. On file transfer invoicing API hit, we will get some file related details, compress it and store to a temporary folder which later we will delete in a smart way.

Here is some code for each and every step :
File Invoicing API Endpoint:

@server.route('/api/download', methods=['POST'])
def add_download_request():
    token = token_validator(request.headers['token'])
    if token is not None:
        # some logical way to decide a unique id for a request,    something like UUID based
        # and we will run a subprocess to compress the file
        subprocess.call('python compression.py <all required arguments goes here> &') # & for daemon process
        return generate_unique_id('<some file related key>')

    elif token is not None:
        return '{"error":"not authorized"}', 403
    else:
        return '{"error":"token error"}', 403

Compression of files :
We would be using zlib and zipfile libraries in Python for compression work.
A simple script, compression.py, for compression work where arguments like file_list and file_name would be passed from subprocess call on main thread

def compress(file_list, file_name):
   try:
      zip_path = get_zip_path(file_name)
      zip_file = zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED)
      for files in file_list:
         zip_file.write(files, basename(files))
      zip_file.close()
      logging.info('Compression of files is done, written to following file {0}'.format(zip_path))
      return zip_path
   except Exception as e:
      logging.error('Exception occurred during compression {0}'.format(e)) # some logging stuffs

def dl_config_reader():
   script_path = os.path.abspath(os.path.dirname(__file__))
   path = os.path.join(script_path, "../dl.conf") # path configs
   conf_str = ''
   with open(path, 'r') as conf_file:
      conf_str = conf_file.read()
      conf_file.close()
   return json.loads(conf_str)


def get_zip_path(file_name):
   conf_json = dl_config_reader()
   tmp_dir = conf_json['tmp_folder']
   if not os.path.exists(tmp_dir):  # create temp directory for zip
      os.makedirs(tmp_dir)
   zip_path = tmp_dir + '/' + file_name + '.zip'
   return zip_path

Acknowledgement API for compression status :
A database mapping could be useful in this case where you will change the status of file compression from it’s unique id. A browser client will ask for file as soon server responds compression is done for acknowledgement API.

Document transfer protocol from browser client to server and send the file in response :
For this we would be using simple Flask in-built send_file which binds file in IO streams and browser acknowledge as document/file with it’s tags.
A simple code for this : (All the functions name are according to their work)

def send_file_from_path():
   token = token_validator(request.args['token'])
   if token is not None:
      try:
         gid = request.args.get('gid')
         logging.info('User asked for file, having GID ' + gid)
         id = get_id_from_gid(gid)
         download_path = get_download_path(id)
         download_name = get_download_name_from_id(id)
         file_path = compression_handler.compress(file_list=[download_path], file_name=download_name)
      except Exception as e:
         logging.error(" get file API (/api/get/file) got wrong arguments, thrown an error :: %s" % e)
         return Response("error", status=200)
      
      try:
         download_name += '.zip'
         return send_file(filename_or_fp=file_path, attachment_filename=download_name
                      , as_attachment=True)
      except Exception as e:
         logging.error("File sending has a exception. When sending file, we got :: %s" % e)
         return Response("File you are trying to access is not available to us. Please ask admin to check the server"
                     , status=200)
   else:
      return Response("Invalid Token in request", 403)

send_file will need the path of file, the attachment type and file name.

More robust way would be implementing WSGI techniques for request handling and invoking zlib with 9th level compression in short timespan compression. Zipfile default use zlib for compression things but it can’t compress to the same which zlib can do for I/O streams.

Thank you for your time, ping me, comment me for any help :)