ich stehe gerade vor dem Problem, wie man denn eine „Nachfrage“ aus einer Funktion bewerkstelligen kann.
Code: Alles auswählen
def upload(file_entry, expiry, server_data, ssh_client, callback=None):
sftp = ssh_client.open_sftp()
remote_file_name = os.path.join(server_data["remote_path"] + file_entry["file_name"])
try:
sftp.stat(remote_file_name)
overwrite_yesno = input("Die Datei ist bereits auf dem Server vorhanden. Soll sie überschrieben werden? [j/n] ")
if overwrite_yesno == "j":
sftp.remove(remote_file_name)
else:
return None
except FileNotFoundError as e:
pass
try:
sftp.put(file_entry["file_entry"],
remote_file_name,
callback=callback)
except TypeError as e:
sftp.putfo(file_entry["file_entry"],
remote_file_name,
file_entry["file_size"],
callback=callback)
database_entry = utilities.create_csv([remote_file_name, expiry])
with sftp.file(server_data["remote_database"], mode="a") as database_file:
database_file.write(database_entry + "\n")
sftp.close()
return server_data["url"] + file_entry["file_name"]
) Abfrage machen, aber ich rufe die Funktion jetzt auch innerhalb eines QThreads in der GUI auf. Und da stehe ich jetzt vor dem Problem, wie ich denn dazwischen kommunizieren kann. Mein QThread sieht so aus:Code: Alles auswählen
class UploadThread(QtCore.QThread):
transferred_bytes = QtCore.pyqtSignal(int)
upload_finished = QtCore.pyqtSignal(list)
def __init__(self, server_data, files, expiry):
super().__init__()
self.server_data = server_data
self.files = files
self.expiry = expiry
self.overall_file_size = 0
for file_entry in files:
self.overall_file_size += file_entry["file_size"]
self.already_uploaded_size = 0
def run(self):
ssh_client = ssh.connect_to_ssh(self.server_data)
ssh.check_server_requirements(self.server_data, ssh_client)
uploaded_files = []
for file_entry in self.files:
uploaded_file = ssh.upload(file_entry,
self.expiry,
self.server_data,
ssh_client,
self.upload_callback)
if uploaded_file is not None:
uploaded_files.append(uploaded_file)
self.already_uploaded_size += file_entry["file_size"]
ssh_client.close()
self.upload_finished.emit(uploaded_files)
def upload_callback(self, bytes_transferred, bytes_total):
self.transferred_bytes.emit(self.already_uploaded_size + bytes_transferred)
Sollte ich dafür dann eine Callback-Funktion einbauen? Aber dann kann der ja auch nicht wirklich „warten“, bis irgend etwas passiert.
Oder muss ich die ganze upload-Funktion komplett auftrennen und das in dem QThread alles einzeln aufrufen? Sprich das Vorhandensein-Überprüfen vor dem eigentlichen Upload überprüfen?
Danke!
), dann musst Du alles, was mit dem FTP-Transfer zu tun hat so unabhängig vom QThread usw. kapseln, dass Du aus Deinem GUI-Tool eben nur noch diese Funktionalität, die Du brauchst aufrufen kannst und musst.