有没有办法在没有阻塞的情况下压缩文件?
import zipfile
from twisted.internet import defer
from twisted.internet import reactor
def zip_files(file_list, path, output_Zip):
zip_handle = zipfile.ZipFile(output_zip, mode='w', allowZip64=True)
try:
for i in file_list:
zip_handle.write(i)
zip_handle.close()
return True
except Exception as e:
return False
def print_zip(res):
print res
return res
file_list = ['path_to_file1','path_to_file2']
output_path = 'full_path_to_output_zip'
d = defer.Deferred()
d.addCallback(lambda _: zip_files(file_list, output_path)
d.addCallback(print_zip)
zip_result = d
reactor.run()
到目前为止,我有这个。虽然它确实有效,但触发拉链过程会导致扭曲阻塞并等到最初的拉链工作。完了。我宁愿它终止现有的拉链工作'并开始新的。
答案 0 :(得分:1)
也许是这样的,使用DeferredList
deferToThread
来阻止编写zip文件:
import zipfile
import logging
from twisted.internet import threads, defer
from twisted.internet import reactor
log = logging.getLogger()
log.addHandler(logging.StreamHandler())
log.setLevel(logging.INFO)
def zip_file(input_path, output_path):
with zipfile.ZipFile(output_path, mode='w', allowZip64=True) as zip_handle:
zip_handle.write(input_path)
def log_failure(err):
log.exception("error: %s", err)
def zip_file_and_catch_error(input_path, output_path):
d = threads.deferToThread(zip_file, input_path, output_path)
d.addErrback(log_failure)
return d
def main():
input_paths = ['path_to_file1','path_to_file2']
output_paths = ['path_out1','path_out2']
assert len(input_paths) == len(output_paths)
dl = defer.DeferredList([zip_file_and_catch_error(input_path, output_path)
for input_path, output_path in zip(input_paths, output_paths)])
dl.addCallback(lambda result: log.info("result: %s", result))
dl.addBoth(lambda _: reactor.callLater(0, reactor.stop))
reactor.run()
if __name__ == "__main__":
main()
答案 1 :(得分:0)
import zipfile
from twisted.internet import defer, reactor
def main():
file_list = ['path_to_file1','path_to_file2']
output_path = 'full_path_to_output.zip'
zip_obj = zipfile.ZipFile(output_path, mode='w', allowZip64=True)
d = zip_files(zip_obj, file_list)
d.addCallback(handle_success)
d.addErrback(handle_error)
d.addBoth(close_zip_obj, zip_obj = zip_obj)
@defer.inlineCallbacks
def zip_files(zip_obj, file_list):
for item in file_list:
yield zip_obj.write(item)
# handle "interrupts" here
def handle_success(ignore):
print('Done zipping')
def handle_error(failure):
print('Error: {0}'.format(failure.value))
def close_zip_obj(ignore, zip_obj):
print('Closing zip object')
zip_obj.close()
main()
reactor.run()
我试图让我的例子变得简单,以便Twisted的新手不会感到困惑。 ZipFile
对象在外部创建并传递到zip_files()
(现在用@inlineCallbacks
修饰并返回'延迟'),这样可以在必要时轻松访问它。处理成功和错误回调(通过addCallback/addErrback
)更新这些功能以满足您的需求。最后,一旦完成压缩,从主函数传递到ZipFile
的{{1}}对象将被关闭。这应该可以很快地处理大量中等大小的文件。对于大型文件,“should”可以使用原始代码在close_zip_obj()
中执行任务。
但是,你发表了一个非常模糊的评论:
我宁愿终止现有的“拉链工作”并开始新的工作。
这假设如果你在拉链中间,你想要停止当前的拉链并开始另一个拉链。使用deferToThread
或任何线程方法,在线程之间传递标志,设置/取消设置锁以及与其他线程同步变得冗长乏味。如果您决定使用线程,请记住这一点。