Get Progress Back From Shutil File Copy Thread
Solution 1:
shutil.copy() doesn't offer any options to track the progress, no. At most you could monitor the size of the destination file (using os.* functions on the target filename).
The alternative would be to implement your own copy function. The implementation is really quite simple; shutil.copy() is basically a shutil.copyfile() plus shutil.copymode() call; shutil.copyfile() in turn delegates the real work to shutil.copyfileobj() (links to the Python 3.8.2 source code).
Implementing your own shutil.copyfileobj() to include progress should be trivial; inject support for a callback function to report inform your program each time another block has copied:
import os
import shutil
defcopyfileobj(fsrc, fdst, callback, length=0):
try:
# check for optimisation opportunityif"b"in fsrc.mode and"b"in fdst.mode and fsrc.readinto:
return _copyfileobj_readinto(fsrc, fdst, callback, length)
except AttributeError:
# one or both file objects do not support a .mode or .readinto attributepassifnot length:
length = shutil.COPY_BUFSIZE
fsrc_read = fsrc.read
fdst_write = fdst.write
copied = 0whileTrue:
buf = fsrc_read(length)
ifnot buf:
break
fdst_write(buf)
copied += len(buf)
callback(copied)
# differs from shutil.COPY_BUFSIZE on platforms != Windows
READINTO_BUFSIZE = 1024 * 1024def_copyfileobj_readinto(fsrc, fdst, callback, length=0):
"""readinto()/memoryview() based variant of copyfileobj().
*fsrc* must support readinto() method and both files must be
open in binary mode.
"""
fsrc_readinto = fsrc.readinto
fdst_write = fdst.write
ifnot length:
try:
file_size = os.stat(fsrc.fileno()).st_size
except OSError:
file_size = READINTO_BUFSIZE
length = min(file_size, READINTO_BUFSIZE)
copied = 0withmemoryview(bytearray(length)) as mv:
whileTrue:
n = fsrc_readinto(mv)
ifnot n:
breakelif n < length:
with mv[:n] as smv:
fdst.write(smv)
else:
fdst_write(mv)
copied += n
callback(copied)
and then, in the callback, compare the copied size with the file size.
Note that in the above implementation we look for the opportunity to use a different method for binary files, where you can use fileobj.readinto() and a memoryview object to avoid redundant data copying; see the original _copyfileobj_readinto() implementation for comparison.
footnote to … delegates the real work to shutil.copyfileobj(): As of Python 3.8, on OS X and Linux the copyfile() implementation delegates file copying to OS-specific, optimised system calls (to fcopyfile() and sendfile(), respectively) but these calls have no hooks whatsoever to track progress, and so if you need to track progress you'd want to disable these delegation paths anyway. On Windows the code uses the aforementioned _copyfileobj_readinto() function.
Solution 2:
I combined Martijn Pieters answer with some progress bar code from this answer with modifications to work in PyCharm from this answer which gives me the following. The function copy_with_progress was my goal.
import os
import shutil
defprogress_percentage(perc, width=None):
# This will only work for python 3.3+ due to use of# os.get_terminal_size the print function etc.
FULL_BLOCK = '█'# this is a gradient of incompleteness
INCOMPLETE_BLOCK_GRAD = ['░', '▒', '▓']
assert(isinstance(perc, float))
assert(0. <= perc <= 100.)
# if width unset use full terminalif width isNone:
width = os.get_terminal_size().columns
# progress bar is block_widget separator perc_widget : ####### 30%
max_perc_widget = '[100.00%]'# 100% is max
separator = ' '
blocks_widget_width = width - len(separator) - len(max_perc_widget)
assert(blocks_widget_width >= 10) # not very meaningful if not
perc_per_block = 100.0/blocks_widget_width
# epsilon is the sensitivity of rendering a gradient block
epsilon = 1e-6# number of blocks that should be represented as complete
full_blocks = int((perc + epsilon)/perc_per_block)
# the rest are "incomplete"
empty_blocks = blocks_widget_width - full_blocks
# build blocks widget
blocks_widget = ([FULL_BLOCK] * full_blocks)
blocks_widget.extend([INCOMPLETE_BLOCK_GRAD[0]] * empty_blocks)
# marginal case - remainder due to how granular our blocks are
remainder = perc - full_blocks*perc_per_block
# epsilon needed for rounding errors (check would be != 0.)# based on reminder modify first empty block shading# depending on remainderif remainder > epsilon:
grad_index = int((len(INCOMPLETE_BLOCK_GRAD) * remainder)/perc_per_block)
blocks_widget[full_blocks] = INCOMPLETE_BLOCK_GRAD[grad_index]
# build perc widget
str_perc = '%.2f' % perc
# -1 because the percentage sign is not included
perc_widget = '[%s%%]' % str_perc.ljust(len(max_perc_widget) - 3)
# form progressbar
progress_bar = '%s%s%s' % (''.join(blocks_widget), separator, perc_widget)
# return progressbar as stringreturn''.join(progress_bar)
defcopy_progress(copied, total):
print('\r' + progress_percentage(100*copied/total, width=30), end='')
defcopyfile(src, dst, *, follow_symlinks=True):
"""Copy data from src to dst.
If follow_symlinks is not set and src is a symbolic link, a new
symlink will be created instead of copying the file it points to.
"""if shutil._samefile(src, dst):
raise shutil.SameFileError("{!r} and {!r} are the same file".format(src, dst))
for fn in [src, dst]:
try:
st = os.stat(fn)
except OSError:
# File most likely does not existpasselse:
# XXX What about other special files? (sockets, devices...)if shutil.stat.S_ISFIFO(st.st_mode):
raise shutil.SpecialFileError("`%s` is a named pipe" % fn)
ifnot follow_symlinks and os.path.islink(src):
os.symlink(os.readlink(src), dst)
else:
size = os.stat(src).st_size
withopen(src, 'rb') as fsrc:
withopen(dst, 'wb') as fdst:
copyfileobj(fsrc, fdst, callback=copy_progress, total=size)
return dst
defcopyfileobj(fsrc, fdst, callback, total, length=16*1024):
copied = 0whileTrue:
buf = fsrc.read(length)
ifnot buf:
break
fdst.write(buf)
copied += len(buf)
callback(copied, total=total)
defcopy_with_progress(src, dst, *, follow_symlinks=True):
if os.path.isdir(dst):
dst = os.path.join(dst, os.path.basename(src))
copyfile(src, dst, follow_symlinks=follow_symlinks)
shutil.copymode(src, dst)
return dst
Solution 3:
This might be a bit hacky but it works:
"""
Copying a file and checking its progress while it's copying.
"""import os
import shutil
import threading
import time
des = r'<PATH/TO/SPURCE/FILE>'
src = r'<PATH/TO/DESTINATION/FILE>'defchecker(source_path, destination_path):
"""
Compare 2 files till they're the same and print the progress.
:type source_path: str
:param source_path: path to the source file
:type destination_path: str
:param destination_path: path to the destination file
"""# Making sure the destination path existswhilenot os.path.exists(destination_path):
print"not exists"
time.sleep(.01)
# Keep checking the file size till it's the same as source filewhile os.path.getsize(source_path) != os.path.getsize(destination_path):
print"percentage", int((float(os.path.getsize(destination_path))/float(os.path.getsize(source_path))) * 100)
time.sleep(.01)
print"percentage", 100defcopying_file(source_path, destination_path):
"""
Copying a file
:type source_path: str
:param source_path: path to the file that needs to be copied
:type destination_path: str
:param destination_path: path to where the file is going to be copied
:rtype: bool
:return: True if the file copied successfully, False otherwise
"""print"Copying...."
shutil.copyfile(source_path, destination_path)
if os.path.exists(destination_path):
print"Done...."returnTrueprint"Filed..."returnFalse
t = threading.Thread(name='copying', target=copying_file, args=(src, des))
# Start the copying on a separate thread
t.start()
# Checking the status of destination file on a separate thread
b = threading.Thread(name='checking', target=checker, args=(src, des))
b.start()
Solution 4:
No, it can't be done this way, because shutil.copy doesn't have any means of providing progress.
But you can write your own copy function (or even fork the code from shutil--notice that it's one of the modules that includes a link to the source at the top, meaning it's meant to be as useful for sample code as for just using as-is). Your function can, e.g., take a progress callback function as an extra argument and calls it after each buffer (or each N buffers, or each N bytes, or each N seconds). Something like:
defcopy(src, dst, progress):
# ...for something:
progress(bytes_so_far, bytes_total)
# ...
progress(bytes_total, bytes_total)
Now, that callback is still going to be called in the background thread, not the main thread. With most GUI frameworks, that means it can't directly touch any GUI widgets. But most GUI frameworks have a way to post a message to the main thread's event loop from a background thread, so just make the callback do that. With Qt you do this with signals and slots, exactly the same way you do within the main thread; there's lots of great tutorials out there if you don't know how.
Alternatively, you could do it the way you suggested: have the main thread signal the background thread (e.g., by posting on a queue.Queue or triggering an Event or Condition) and have your copy function check for that signal every time through the loop and respond. But that seems both more complicated and less responsive.
One more thing: Qt has its own threading library, and you may want to use it instead of Python's native one, because you can attach a slot directly to QThread object and make that your callback. I'm not sure, but Qt might even have its own file-copy-with-progress methods in there somewhere; they try to wrap up everything that might be at all different between platforms and vaguely related to GUIs.
Solution 5:
In addition to Martijn Pieters excellent reply, if (like me, I'm an idiot) you need to figure out how to pass the actual callback into the copyfileobj() function, you can do it like this:
defmyscopefunction():
### Inside wherever you want to call the copyfileobj() function, you can### make a nested function like so:defprogress(bytescopied):
updateui(bytescopied) #update your progress bar or whatever#and then call it like this
copyfileobj(source,destination,progress)
...
Post a Comment for "Get Progress Back From Shutil File Copy Thread"