使用 zipfile 解压含有中文文件名的 zip 文件

【Python】使用 zipfile 解压含有中文文件名的 zip 文件_secsilm的博客-CSDN博客 (opens new window)

with open(os.path.join(file_father_dir, new_zip_file), 'wb')as output_file:  # 创建并打开新文件
    with zip_file.open(file, 'r')as origin_file:  # 打开原文件
        shutil.copyfileobj(origin_file, output_file)# 将原文件内容复制到新文件
def extract_zip(file_path, file_father_dir, thread_queue):
"""解压zip文件并返回文件列表"""
print(file_path, file_father_dir,33222111)
zip_file = zipfile.ZipFile(file_path)
# 获取压缩包里所有文件
    zip_list = zip_file.namelist()
print(zip_file,111111111111111111,zip_list)

# 统计压缩包中的文件总数与完成度
    files_count = len(zip_list)
finished_count = 0
    percent = 0
    new_zip_list =[]
try:
        for file in zip_list:
            # zip_file.extract(file, file_father_dir)
            try:
                new_zip_file = file.encode('cp437').decode('gbk')
except:
                new_zip_file = file.encode('cp437').decode('utf-8')

with open(os.path.join(file_father_dir, new_zip_file), 'wb')as output_file:  # 创建并打开新文件
                with zip_file.open(file, 'r')as origin_file:  # 打开原文件
                    shutil.copyfileobj(origin_file, output_file)# 将原文件内容复制到新文件

            print(new_zip_file,111111,22222222222222222222222222222222)
new_zip_list.append(new_zip_file)

# os.rename(os.path.join(file_father_dir, file), os.path.join(file_father_dir, new_zip_file))

            finished_count += 1
            # 返回解压进度(解压完成时返回10%,后90%属于文件上传)
            if percent != finished_count / files_count * 100 // 10:
                percent = finished_count / files_count * 100 // 10
                # 发送异步信息
                thread_queue.put(my_response(data={'progress_percent': percent}))
zip_file.close()
thread_queue.put(my_response(data={'progress_percent': 10}))
os.remove(file_path)
except Exception as e:
        print(e,11111111111111111111111111111111111111111111111)
logging.error(e)
return new_zip_list
import os
import logging

# ====================================== 本地调试时注释掉以下代码 ======================================
import shutil
import queue
import threading
import yaml

DEBUG = False if os.environ.get('CABITS_ENV_PATH') else True
if DEBUG:
    env_path = r'../env.yml'
else:  # 读取configmap中的环境变量
    env_path = os.environ['CABITS_ENV_PATH']
with open(env_path, 'r', encoding='utf-8') as f:
    file_content = f.read()
content = yaml.load(file_content, yaml.FullLoader)
for key, value in content.items():
    if value is not None:
        logging.error('{} =======> {}'.format(key, value))
        os.environ[key] = str(value)
# ===================================
import re
import zipfile
import tarfile
import rarfile
import py7zr
from flask import Flask, request
from flask_socketio import SocketIO, emit

from common.response import my_response
from common import stat
from common.utils import get_file_md5, get_file_suffix, get_file_size
from libs.S3_client import s3_client

app = Flask(__name__)
app.config['SECRET_KEY'] = 'secret!'
socketio = SocketIO(app, cors_allowed_origins="*", async_mode='eventlet', logger=True, engineio_logger=True,
                    path='/compressed_files')

@app.route('/api/v1/test', methods=['GET'])
def test() -> dict:
    """测试接口"""
    return {
        'code': 1000,
        'message': '测试成功'
    }

def extract_zip(file_path, file_father_dir, thread_queue):
    """解压zip文件并返回文件列表"""
    zip_file = zipfile.ZipFile(file_path)
    # 获取压缩包里所有文件
    zip_list = zip_file.namelist()
    # 统计压缩包中的文件总数与完成度
    files_count = len(zip_list)
    finished_count = 0
    percent = 0
    new_zip_list = []
    try:
        for file in zip_list:
            zip_file.extract(file, file_father_dir)
            try:
                new_zip_file = file.encode('cp437').decode('gbk')
            except:
                new_zip_file = file.encode('cp437').decode('utf-8')
            new_zip_list.append(new_zip_file)
            os.rename(os.path.join(file_father_dir, file), os.path.join(file_father_dir, new_zip_file))
            finished_count += 1
            # 返回解压进度(解压完成时返回10%,后90%属于文件上传)
            if percent != finished_count / files_count * 100 // 10:
                percent = finished_count / files_count * 100 // 10
                # 发送异步信息
                thread_queue.put(my_response(data={'progress_percent': percent}))
        zip_file.close()
        thread_queue.put(my_response(data={'progress_percent': 10}))
        os.remove(file_path)
    except Exception as e:
        print(e)
        logging.error(e)
    return new_zip_list

def extract_rar(file_path, file_father_dir, thread_queue):
    """解压rar文件"""
    rar_list = []
    try:
        os.makedirs(file_father_dir)
    except:
        pass
    try:
        rar_file = rarfile.RarFile(file_path)
        # 获取压缩包里所有文件
        rar_list = rar_file.namelist()
        rar_file.extractall(file_father_dir)
        rar_file.close()
        thread_queue.put(my_response(data={'progress_percent': 10}))
        os.remove(file_path)

    except Exception as e:
        print(e)
        logging.error(e)
    return rar_list

def extract_7z(file_path, file_father_dir, thread_queue):
    """解压7z文件"""
    sevenz_list = []
    try:
        sevenz_file = py7zr.SevenZipFile(file_path)
        sevenz_list = sevenz_file.getnames()
        sevenz_file.extractall(file_father_dir)
        sevenz_file.close()
        thread_queue.put(my_response(data={'progress_percent': 10}))
        os.remove(file_path)

    except Exception as e:
        print(e)
        logging.error(e)
    return sevenz_list

def extract_tar(file_path, file_father_dir, thread_queue):
    """解压tar文件"""
    tar_list = []
    try:
        tar_file = tarfile.open(file_path)
        # 获取压缩包里所有文件
        tar_list = tar_file.getnames()
        # 统计压缩包中的文件总数与完成度
        files_count = len(tar_list)
        finished_count = 0
        percent = 0
        for name in tar_list:
            tar_file.extract(name, path=file_father_dir)
            finished_count += 1
            # 返回解压进度(解压完成时返回10%,后10%属于文件上传)
            if percent != finished_count / files_count * 100 // 10:
                percent = finished_count / files_count * 100 // 10
                # 发送异步信息
                thread_queue.put(my_response(data={'progress_percent': percent}))
        tar_file.close()
        thread_queue.put(my_response(data={'progress_percent': 10}))
        os.remove(file_path)

    except Exception as e:
        print(e)
        logging.error(e)
    return tar_list

def filter_file_list(file_list, resource_type, thread_queue):
    """筛选出符合资源类型的数据"""
    file_list_filter = []
    if resource_type == 'image':
        for file in file_list:
            if re.match(r'.*\\.(png|jpg|jpeg|bmp)$', file):
                file_list_filter.append(file)

    elif resource_type == 'label':
        for file in file_list:
            if re.match(r'.*\\.(txt|xml|json)$', file):
                file_list_filter.append(file)
    else:
        logging.error('暂不支持该格式上传')
        thread_queue.put(my_response(code=stat.ServerErr, message='暂不支持该格式的上传'))
        return False

    return file_list_filter

def upload_minio(file_father_dir, file_list, workspace_id, resource_type, thread_queue, host):
    """上传文件到Minio"""
    # 过滤文件列表
    file_list = filter_file_list(file_list, resource_type, thread_queue)
    # 记录上传进度
    total_count = len(file_list)
    finished_count = 0
    percent = 10
    # 初始化上传文件信息列表
    upload_response = []
    # 如果桶不存在则创建桶
    logging.error(workspace_id)

    if total_count == 0:
        thread_queue.put(my_response(data={'progress_percent': 100}))
        thread_queue.put(my_response(data={'results': [], 'count': total_count}))
    else:
        for file in file_list:
            # 初始化上传文件的信息
            file_info = dict()
            # 获取文件的md5, suffix, size, download
            file_info['md5'] = get_file_md5(os.path.join(file_father_dir, file))
            file_info['suffix'] = get_file_suffix(file)
            file_info['size'] = get_file_size(os.path.join(file_father_dir, file))
            file_info['name'] = os.path.split(file)[1].rsplit('.', 1)[0]
            object_name = '/'.join([workspace_id, resource_type, f'{file_info["md5"]}.{file_info["suffix"]}'])

            # 判断文件是否已在Minio中存在，若存在则返回链接， 不存在则上传
            if not s3_client.object_exists(obj_name=object_name):
                s3_client.upload_file(object_name, os.path.join(file_father_dir, file))
            # 删除已上传的文件
            os.remove(os.path.join(file_father_dir, file))
            file_info['download_url'] = '/' + s3_client.get_download_url(workspace_id,
                                                                         f'{file_info["md5"]}.{file_info["suffix"]}',
                                                                         "image")
            # 只有percent整数发生变化时才向前端发送请求
            finished_count += 1
            if percent != int(finished_count / total_count * 100 * 0.9) + 10:
                percent = int(finished_count / total_count * 100 * 0.9) + 10
                # 发送请求
                thread_queue.put(my_response(data={'progress_percent': percent}))
            upload_response.append(file_info)
        thread_queue.put(my_response(data={'results': upload_response, 'count': total_count}))

@socketio.on('connect', namespace='/compressed_files')
def connect():
    emit('response', my_response(code=stat.OK, message='连接成功'))

@socketio.on('message', namespace='/compressed_files')
def handle_json(data):
    emit('response', my_response(message='开始解压'))
    suffix = data.get('suffix')
    md5 = data.get('md5')
    workspace_id = data.get('workspace_id')
    resource_type = data.get('type')

    thread_queue = queue.Queue()
    thread = threading.Thread(target=loop, args=(thread_queue, suffix, md5, workspace_id, resource_type, request.host),
                              daemon=True)
    thread.start()
    while True:
        if not thread_queue.empty():
            response = thread_queue.get_nowait()
            if response is not None:
                if response == 'exit':
                    break
                emit('response', response, namespace='/compressed_files')
        socketio.sleep(1)

def loop(thread_queue, suffix, md5, workspace_id, resource_type, host):
    # 获取文件的路径与父路径
    file_path = f'/opt/{md5}.{suffix}'
    file_father_dir = f'/update/{md5}'
    s3_client.download_file(f'{workspace_id}/{resource_type}/{md5}.{suffix}', file_path)
    # 删除旧的文件夹
    try:
        shutil.rmtree(file_father_dir)
    except Exception as e:
        pass

    if not os.path.exists(file_path):
        thread_queue.put(my_response(code=stat.ServerErr, message='文件不存在，无法解压'))
        thread_queue.put('exit')
        return False

    # 校验资源类型
    if resource_type != 'image' and resource_type != 'label':
        thread_queue.put(my_response(code=stat.ServerErr, message='暂不支持该格式的上传'))
        thread_queue.put('exit')
        return False

    # 根据不同的文件类型选择不同的解压方法
    if suffix == 'zip':
        file_list = extract_zip(file_path, file_father_dir, thread_queue)
    elif suffix == 'rar':
        file_list = extract_rar(file_path, file_father_dir, thread_queue)
    elif suffix == '7z':
        file_list = extract_7z(file_path, file_father_dir, thread_queue)
    elif suffix == 'jar':
        file_list = extract_zip(file_path, file_father_dir, thread_queue)
    elif suffix == 'tar':
        file_list = extract_tar(file_path, file_father_dir, thread_queue)
    else:
        thread_queue.put(my_response(message='解压失败', code=stat.ServerErr))
        thread_queue.put('exit')
        return False
    # 根据文件列表来上传文件并返回文件的md5, suffix, size, name, download_url
    upload_minio(file_father_dir, file_list, workspace_id, resource_type, thread_queue, host)
    thread_queue.put('exit')

if __name__ == '__main__':
    socketio.run(app, host='0.0.0.0', port=8000, debug=True)

1