Holen Sie Fortschritte wieder aus shutil-Datei kopieren thread

shutil.copy() bietet keine Optionen, um die Fortschritte, Nein. Bei den meisten konnte man beobachten, die Größe der Ziel-Datei (mit os.* Funktionen auf dem Ziel-Dateinamen).

Die alternative wäre die Umsetzung in Ihre eigene kopieren-Funktion. Die Umsetzung ist eigentlich ganz einfach; shutil.copy() ist im Grunde ein shutil.copyfile() plus shutil.copymode() nennen; shutil.copyfile() wiederum delegiert die eigentliche Arbeit an shutil.copyfileobj() (links zu den Python-source-code).

Umsetzung Ihrer eigenen shutil.copyfileobj() enthalten Fortschritt sollte trivial sein; injizieren Unterstützung für eine callback-Funktion zu melden, informieren Sie Ihr Programm jedes mal einen anderen block kopiert hat:

def copyfileobj(fsrc, fdst, callback, length=16*1024):
    copied = 0
    while True:
        buf = fsrc.read(length)
        if not buf:
            break
        fdst.write(buf)
        copied += len(buf)
        callback(copied)

und vergleichen Sie die copied Größe mit der Größe der Datei.

Nein, es kann nicht getan werden, auf diese Weise, weil shutil.copy keine Mittel, der Bereitstellung von Fortschritt.

Aber Sie können schreiben Sie Ihre eigene Kopie der Funktion (oder auch Gabel den code aus shutil - feststellen, dass es ist eines der Module, die mit einem link zu die Quelle an der Spitze, was bedeutet, es ist gemeint als nützlich für Beispiel-code nur für die Verwendung als-ist). Ihre Funktion kann, z.B., nehmen Sie ein progress-callback-Funktion als zusätzliches argument an und nennt es nach jeder Puffer (oder jedem N-Puffer, oder jedem N-Byte oder jedes N-Sekunden). So etwas wie:

def copy(src, dst, progress):
    # ...
    for something:
        progress(bytes_so_far, bytes_total)
        # ...
    progress(bytes_total, bytes_total)

Nun, dass callback ist immer noch aufgerufen werden, in den hintergrund-thread, nicht der Haupt-thread. Bei den meisten GUI-frameworks, das heißt, es kann nicht direkt berühren alle GUI-widgets. Aber die meisten GUI-frameworks haben einen Weg, um eine Nachricht zu der Haupt-thread die event-Schleife, die von einem hintergrund-thread, also machen Sie doch einfach den Rückruf machen. Mit Qt tun Sie dies mit Signale und slots, genau auf die gleiche Weise tun, innerhalb des main-thread, da gibt es viele tolle Anleitungen, wenn Sie nicht wissen, wie.

Alternativ, Sie könnte es tun die Art und Weise, die Sie vorgeschlagen: die Haupt-thread-signal die hintergrund-thread (z.B., durch die Veröffentlichung auf einer queue.Queue oder Auslösung einer Event oder Condition) und haben Ihre copy Funktion überprüfen, dass das signal jedes mal durch die Schleife und reagieren. Aber das scheint ja komplizierter und weniger zu reagieren.

Eins noch: Qt hat seine eigenen threading-Bibliothek, und möchten Sie vielleicht, es zu benutzen, anstatt Python ' s Muttersprache, weil Sie Anhängen können ein Ablagefach direkt zu QThread Objekt und machen, dass Ihr Rückruf. Ich bin mir nicht sicher, aber Qt kann sogar seine eigenen Datei-kopieren-mit-Fortschritte-Methoden in dort irgendwo, Sie versuchen zu wickeln alles das könnte sein, bei allen anderen zwischen Plattformen und vage Bezug auf GUIs.

Das könnte etwas hacky, aber es funktioniert:

"""
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>'


def checker(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 exists
    while not os.path.exists(destination_path):
        print "not exists"
        time.sleep(.01)

    # Keep checking the file size till it's the same as source file
    while 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", 100


def copying_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...."
        return True

    print "Filed..."
    return False


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()