Progress bar with Python Dropbox Api

Question

I'm working making a progress bar for my python Dropbox app using the Dropbox API. The problem is I can't figure out how to get the number of bytes written so far so that I can build it. Is there any way to do this using the python Dropbox API? If not could I measure the bytes being sent out from my system instead, possibly using the os module?

I'm trying to get it to work with get_chunked_loader, but it would be great if I could get the bytes written for put_file() as well as file_copy() and file_move also(). My code so far is something like this:

if (file_size >= 4194304):                    
    big_file = open(path_to_file, 'rb')
    uploader = client.get_chunked_uploader(big_file)
    print "uploading " + path_to_file
    while uploader.offset < file_size:  
        percent_complete = bytes_written / file_size * 100
        clearscreen()
        print "%.2f" % percent_complete + "%"

Thanks!

Answer 1

I recreate ChunkedUploader

f = open(filetoupload, 'rb')
uploader = MMChunkedUploader(self.client, f, file_size, 1024*200)  
uploader.upload_chunked()
uploader.finish(dropboxfilename)  


class MMChunkedUploader(object):
  """Contains the logic around a chunked upload, which uploads a
   large file to Dropbox via the /chunked_upload endpoint.
   """

  def __init__(self, client, file_obj, length, chunk_size = 4 * 1024 * 1024):
    self.client = client
    self.offset = 0
    self.upload_id = None

    self.last_block = None
    self.file_obj = file_obj
    self.target_length = length
    self.chunk_size=chunk_size
    self.clocknumber=0
    dec=float(self.target_length)/chunk_size - self.target_length//chunk_size
    if dec >0:
      self.totalblock=self.target_length/chunk_size +1
    else:  
      self.totalblock=self.target_length/chunk_size
def upload_chunked(self, chunk_size = 0):
    """Uploads data from this ChunkedUploader's file_obj in chunks, until
    an error occurs. Throws an exception when an error occurs, and can
    be called again to resume the upload.

    Parameters
        chunk_size
          The number of bytes to put in each chunk. (Default 4 MB.)
    """
    if chunk_size ==0:
        chunk_size=self.chunk_size

    self.clocknumber=0
    while self.offset < self.target_length:
        self.clocknumber+=1
        print "Block n.", repr(self.clocknumber) , " of " , repr(self.totalblock), " %",  round((float(self.clocknumber)  * 100) / self.totalblock, 0) 

        next_chunk_size = min(chunk_size, self.target_length - self.offset)  #sceglie tra min e chuck size
        if self.last_block == None:
            self.last_block = self.file_obj.read(next_chunk_size)  
            print "Leggo blocco file"

        try:
            (self.offset, self.upload_id) = self.client.upload_chunk(
                StringIO(self.last_block), next_chunk_size, self.offset, self.upload_id)
            self.last_block = None
        except dropbox.rest.ErrorResponse as e:
            # Handle the case where the server tells us our offset is wrong.
            must_reraise = True
            if e.status == 400:
                reply = e.body
                if "offset" in reply and reply['offset'] != 0 and reply['offset'] > self.offset:
                    self.last_block = None
                    self.offset = reply['offset']
                    must_reraise = False
            if must_reraise:
                raise        

def finish(self, path, overwrite=False, parent_rev=None):


        path = "/commit_chunked_upload/%s%s" % (self.client.session.root, dropbox.client.format_path(path))

        params = dict(
            overwrite = bool(overwrite),
            upload_id = self.upload_id
        )

        if parent_rev is not None:
            params['parent_rev'] = parent_rev

        url, params, headers = self.client.request(path, params, content_server=True)

        return self.client.rest_client.POST(url, params, headers)