def run(self):
if not self._task:
logger.error("Download task is empty!")
return None
self._task.run = True
try:
if is_file_url(self._task.url): # 下载文件
res = self._disk.down_file_by_url(self._task.url, self._task,
self._callback)
elif is_folder_url(self._task.url): # 下载文件夹
res = self._disk.down_dir_by_url(self._task, self._callback)
else:
raise UserWarning
if res == 0:
self._task.rate = 1000 # 回调线程可能在休眠
self.update.emit()
else:
self._task.info = why_error(res)
logger.debug(f"Download : res={res}")
self.failed.emit()
except TimeoutError:
self._task.info = "网络连接错误！"
logger.error("Download TimeOut")
self.failed.emit()
except Exception as err:
self._task.info = f"未知错误！err={err}"
logger.error(f"Download error: err={err}")
self.failed.emit()
except UserWarning:
pass
self._task.run = False
self.finished_.emit(self._task)
def run(self):
if not self._is_work:
self._mutex.lock()
self._is_work = True
while True:
self._task_to_queue()
if not self._queues:
break
while self._count >= self._thread:
self.sleep(1)
self._count += 1
task = self._queues.pop()
logger.debug(f"TaskMgr run: {task.url=}")
if task.type == 'dl':
self._workers[task.url] = Downloader(self._disk, task, Callback)
self.mgr_msg.emit(f"准备下载：<font color='#FFA500'>{task.name}</font>", 0)
else:
self._workers[task.url] = Uploader(self._disk, task, Callback, self._allow_big_file)
self.mgr_msg.emit(f"准备上传：<font color='#FFA500'>{task.name}</font>", 0)
try:
self._workers[task.url].finished_.connect(self._add_thread)
self._workers[task.url].proc.connect(self._ahead_msg)
self._workers[task.url].update.connect(self._update_emit)
self._workers[task.url].folder_file_failed.connect(self._ahead_folder_error)
self._workers[task.url].failed.connect(self._ahead_error)
self._workers[task.url].start()
except Exception as err:
logger.error(f"TaskMgr Error: {err=}")
self._is_work = False
self._mutex.unlock()
def run(self):
try:
if is_file_url(self.url): # 下载文件
res = self._disk.down_file_by_url(self.url, self.pwd,
self.save_path,
self._show_progress)
elif is_folder_url(self.url): # 下载文件夹
res = self._disk.down_dir_by_url(
self.url,
self.pwd,
self.save_path,
self._show_progress,
mkdir=True,
failed_callback=self._down_failed)
else:
return
if res == 0:
self.download_rate.emit(self.url, 1000)
else:
self.download_failed.emit(self.url, res)
logger.debug(f"Download res: {res}")
except TimeoutError:
logger.error("Download TimeOut")
self.download_failed.emit(self.url, "网络连接错误！")
except Exception as e:
logger.error(f"Download error: {e=}")
self.download_failed.emit(self.url, f"未知错误！{e}")
def add_task(self, task):
logger.debug(f"TaskMgr add one: {task.added=}, {task.pause=}")
if task.url not in self._tasks.keys():
self._tasks[task.url] = task
task.added = False
task.pause = False
task.info = None
self.start()
def start_task(self, task):
if task.url not in self.downloaders:
self.add_task(task)
elif not self.downloaders[task.url].isRunning():
logger.debug(f"Start job: {task}")
self.downloaders[task.url].start()
self._dl_ing[task.url] = self._dl_ing[task.url]._replace(run=True)
self.update.emit(self._dl_ing)
def del_task(self, task):
logger.debug(f"TaskMgr del: {task.url=}")
if task in self._queues:
self._queues.remove(task)
if task.url in self._tasks:
del self._tasks[task.url]
if task.url in self._workers:
del self._workers[task.url]
def un_serialize(data: bytes):
"""反序列化文件信息数据"""
try:
ret = pickle.loads(data)
if not isinstance(ret, dict):
return None
return ret
except Exception as e: # 这里可能会丢奇怪的异常
logger.debug(f"Pickle e={e}")
return None
def start_task(self, task):
"""开始已暂停任务"""
if task.url not in self._workers:
self.add_task(task)
elif not self._workers[task.url].isRunning():
logger.debug(f"Start job: {task}")
self._workers[task.url].start()
self._tasks[task.url].run = True
self._tasks[task.url].pause = False
self.update.emit()
self.start()
def run(self):
if not self._is_work:
self._mutex.lock()
self._is_work = True
resp = None
try:
resp = requests.get(self._api).json()
except (requests.RequestException, TimeoutError,
requests.exceptions.ConnectionError):
logger.debug("chcek update from github error")
try:
resp = requests.get(self._api_mirror).json()
except:
logger.debug("chcek update from gitee error")
except Exception as e:
logger.error(f"CheckUpdateWorker error: {e=}")
if resp:
try:
tag_name, msg = resp['tag_name'], resp['body']
ver = self._ver.replace('v', '').split('-')[0].split('.')
ver2 = tag_name.replace('v', '').split('-')[0].split('.')
local_version = int(ver[0]) * 100 + int(ver[1]) * 10 + int(
ver[2])
remote_version = int(ver2[0]) * 100 + int(
ver2[1]) * 10 + int(ver2[2])
if remote_version > local_version:
urls = re.findall(r'https?://[-\.a-zA-Z0-9/_#?&%@]+',
msg)
for url in urls:
new_url = f'<a href="{url}">{url}</a>'
msg = msg.replace(url, new_url)
msg = msg.replace('\n', '<br />')
self.infos.emit(tag_name, msg)
if not self._manual: # 打开软件时检测更新
self.bg_update_infos.emit(tag_name, msg)
elif self._manual:
self.infos.emit("0", "目前还没有发布新版本！")
except AttributeError:
if self._manual:
self.infos.emit("v0.0.0", "检查更新时发生异常，请重试！")
except Exception as e:
logger.error(f"Check Update Version error: {e=}")
else:
if self._manual:
self.infos.emit(
"v0.0.0",
f"检查更新时 <a href='{self._api}'>api.github.com</a>、<a href='{self._api_mirror}'>gitee.com</a> 拒绝连接，请稍后重试！"
)
self._manual = False
self._is_work = False
self._mutex.unlock()
else:
if self._manual:
self.infos.emit("v0.0.0", "后台正在运行，请稍等！")
def run(self):
if not self._is_work:
self._mutex.lock()
self._is_work = True
while True:
if not self._tasks:
logger.debug(f"upload finished!")
break
self._furl = list(self._tasks.keys())[0]
self._task = self._tasks[self._furl]
logger.debug(f"run task: {self._task=}")
if not os.path.exists(self._furl):
logger.error(f"upload file not exist : {self._furl}")
msg = f"<b>ERROR :</b> <font color='red'>文件不存在:{self._furl}</font>"
self.code.emit(msg, 3100)
continue
if os.path.isdir(self._furl):
logger.error(f"upload dir : {self._furl}")
msg = f"<b>INFO :</b> <font color='#00CC00'>批量上传文件夹:{self._furl}</font>"
self.code.emit(msg, 30000)
self._disk.upload_dir(self._furl,
self._task.id,
self._show_progress,
None,
self._allow_big_file)
else:
msg = f"<b>INFO :</b> <font color='#00CC00'>上传文件:{self._furl}</font>"
self.code.emit(msg, 20000)
try:
code, fid, isfile = self._disk.upload_file(self._task.furl,
self._task.id,
self._show_progress,
self._allow_big_file)
except TimeoutError:
msg = "<b>ERROR :</b> <font color='red'>网络连接超时，请重试！</font>"
self.code.emit(msg, 3100)
self._task = self._task._replace(info="网络连接超时")
self.update.emit({self._furl: self._task})
except Exception as e:
logger.error(f"UploadWorker error: {e=}")
self._task = self._task._replace(info="未知错误")
self.update.emit({self._furl: self._task})
else:
self._task = self._task._replace(info="上传成功")
if code == LanZouCloud.SUCCESS:
if self._task.set_pwd:
self._disk.set_passwd(fid, self._task.pwd, is_file=isfile)
if self._task.set_desc:
self._disk.set_desc(fid, self._task.desc, is_file=isfile)
del self._tasks[self._furl]
self._is_work = False
self._mutex.unlock()
def stop_task(self, task):
"""暂停任务"""
if task.url in self._workers and self._workers[task.url].isRunning():
logger.debug(f"Stop job: {task.url}")
try:
self._tasks[task.url].pause = True
self._workers[task.url].stop()
self._tasks[task.url].run = False
except Exception as err:
logger.error(f"Stop task: {err=}")
else:
logger.debug(f"Stop job: {task.url} is not running!")
self.update.emit()
def convert_file_size_to_int(size_str: str) -> int:
"""文件大小描述转化为字节大小"""
if 'G' in size_str:
size_int = float(size_str.replace('G', '')) * (1 << 30)
elif 'M' in size_str:
size_int = float(size_str.replace('M', '')) * (1 << 20)
elif 'K' in size_str:
size_int = float(size_str.replace('K', '')) * (1 << 10)
elif 'B' in size_str:
size_int = float(size_str.replace('B', ''))
else:
size_int = 0
logger.debug(f"Unknown size: {size_str}")
return int(size_int)
def _add_thread(self, task):
self.update.emit()
logger.debug(f"TaskMgr count: {self._count=}")
self._count -= 1
del self._workers[task.url]
# 发送所有任务完成信号
failed_task_num = 0
for task in self._tasks.values():
if not task.info:
if task.rate < 1000:
return None
else:
failed_task_num += 1
logger.debug(f"TaskMgr all finished!: {failed_task_num=}")
self.mgr_finished.emit(failed_task_num)
def sum_files_size(files):
"""计算文件夹中所有文件的大小， [files,]: FileInFolder"""
total = 0.0
for file_ in files:
if 'M' in file_.size:
total += float(file_.size.replace('M', '')) * (1 << 20)
elif 'K' in file_.size:
total += float(file_.size.replace('K', '')) * (1 << 10)
elif 'B' in file_.size:
total += float(file_.size.replace('B', ''))
else:
logger.debug(f"Unknow size: {file_.size}")
if total < 1 << 10:
size = "{:.2f} B".format(total)
elif total < 1 << 20:
size = "{:.2f} KB".format(total / (1 << 10))
elif total < 1 << 30:
size = "{:.2f} MB".format(total / (1 << 20))
else:
size = "{:.2f} GB".format(total / (1 << 30))
return size, int(total)
def run(self):
if not self._is_work:
self._mutex.lock()
self._is_work = True
while True:
if not self._tasks:
break
while self._count >= self._thread:
self.sleep(1)
self._count += 1
url = list(self._tasks.keys())[0]
task = self._tasks[url]
logger.debug(f"DownloadMgr run: {task=}")
self.downloaders[url] = Downloader()
self.downloaders[url].set_disk(self._disk)
self.downloaders_msg.emit(
"准备下载：<font color='#FFA500'>{}</font>".format(task.name),
8000)
try:
self.downloaders[url].finished.connect(
lambda: self._add_thread(url))
self.downloaders[url].download_proc.connect(
self._ahead_msg)
self.downloaders[url].download_rate.connect(
self._ahead_rate)
self.downloaders[url].folder_file_failed.connect(
self._ahead_folder_error)
self.downloaders[url].download_failed.connect(
self._ahead_error)
self._dl_ing[url] = task._replace(run=True)
self.downloaders[url].set_values(task.name, task.url,
task.pwd, task.path)
except Exception as exp:
logger.error(f"DownloadMgr Error: {exp=}")
del self._tasks[url]
self._is_work = False
self._mutex.unlock()
def run(self):
try:
if self.cookie:
res = self._disk.login_by_cookie(self.cookie)
if res == LanZouCloud.SUCCESS:
if not self.username:
username = self._disk.get_user_name()
if isinstance(username, str):
self.update_username.emit(username)
logger.debug(f"login by Cookie: {username=}")
self.code.emit(
True,
"<font color='#00CC00'>通过<b>Cookie</b>登录<b>成功</b>！ ≧◉◡◉≦</font>",
5000)
return None
logger.debug(f"login by Cookie err: {res=}")
if (not self.username or not self.password) and not self.cookie:
logger.debug("login err: No UserName、No cookie")
self.code.emit(False, "<font color='red'>登录失败: 没有用户或密码</font>",
3000)
else:
res = self._disk.login(self.username, self.password)
if res == LanZouCloud.SUCCESS:
self.code.emit(
True,
"<font color='#00CC00'>登录<b>成功</b>！ ≧◉◡◉≦</font>",
5000)
_cookie = self._disk.get_cookie()
self.update_cookie.emit(_cookie)
else:
logger.debug(f"login err: {res=}")
self.code.emit(
False, "<font color='red'>登录失败，可能是用户名或密码错误！</font>",
8000)
self.update_cookie.emit(None)
except TimeoutError:
self.code.emit(False, "<font color='red'>网络超时！</font>", 3000)
except Exception as e:
logger.error(f"LoginLuncher error: {e=}")
def add_task(self, task):
if task.furl not in self._tasks.keys():
logger.debug(f"upload add one task: {task}")
self._tasks[task.furl] = task
self.start()
def _task_to_queue(self):
for task in self._tasks.values():
if not task.added and not task.pause and task not in self._queues:
logger.debug(f"TaskMgr task2queue: {task.url=}")
self._queues.append(task)
task.added = True
def stop_task(self, task):
if self.downloaders[task.url].isRunning():
self.downloaders[task.url].stop()
self._dl_ing[task.url] = self._dl_ing[task.url]._replace(run=False)
logger.debug(f"Stop job: {task}")
self.update.emit(self._dl_ing)
def add_tasks(self, tasks: dict):
logger.debug(f"TaskMgr add: {tasks=}")
self._tasks.update(tasks)
self.start()
def add_task(self, task):
if task.url not in self._tasks.keys():
logger.debug(f"DownloadMgr add one: {task=}")
self._tasks[task.url] = task
self.start()
def del_task(self, url):
logger.debug(f"DownloadMgr del: {url=}")
if url in self._dl_ing:
del self._dl_ing[url]
if url in self.downloaders:
del self.downloaders[url]
def _add_thread(self, url):
logger.debug(f"DownloadMgr count: {self._count}")
self._count -= 1
del self.downloaders[url]
def add_tasks(self, tasks: dict):
logger.debug(f"upload add tasks: {tasks.values()}")
self._tasks.update(tasks)
self.start()
