qrpa 1.0.13__py3-none-any.whl → 1.1.50__py3-none-any.whl

qrpa/fun_excel.py

@@ -12,66 +12,112 @@ import concurrent.futures
 from collections import defaultdict
 import threading
 from playwright.sync_api import sync_playwright
+import psutil
+
+import os, sys
+from pathlib import Path
 
 from .fun_base import log, sanitize_filename, create_file_path, copy_file, add_https, send_exception
 
 excel_color_index = {
-    "无色(自动)": 0,  # 透明/默认
-    "黑色": 1,  # #000000
-    "白色": 2,  # #FFFFFF
-    "红色": 3,  # #FF0000
-    "绿色": 4,  # #00FF00
-    "蓝色": 5,  # #0000FF
-    "黄色": 6,  # #FFFF00
-    "粉红色": 7,  # #FF00FF
-    "青绿色": 8,  # #00FFFF
-    "深红色": 9,  # #800000
-    "深绿色": 10,  # #008000
-    "深蓝色": 11,  # #000080
-    "橄榄色(深黄)": 12,  # #808000
-    "紫色": 13,  # #800080
-    "蓝绿色(水色)": 14,  # #008080
-    "灰色（25%）": 15,  # #808080
+    "无色(自动)"   : 0,  # 透明/默认
+    "黑色"         : 1,  # #000000
+    "白色"         : 2,  # #FFFFFF
+    "红色"         : 3,  # #FF0000
+    "绿色"         : 4,  # #00FF00
+    "蓝色"         : 5,  # #0000FF
+    "黄色"         : 6,  # #FFFF00
+    "粉红色"       : 7,  # #FF00FF
+    "青绿色"       : 8,  # #00FFFF
+    "深红色"       : 9,  # #800000
+    "深绿色"       : 10,  # #008000
+    "深蓝色"       : 11,  # #000080
+    "橄榄色(深黄)" : 12,  # #808000
+    "紫色"         : 13,  # #800080
+    "蓝绿色(水色)" : 14,  # #008080
+    "灰色（25%）"    : 15,  # #808080
     "浅灰色(12.5%)": 16,  # #C0C0C0
     # 17-19：系统保留（通常不可用）
-    "深玫瑰红": 20,  # #FF99CC
-    "深金色": 21,  # #FFCC99
-    "深橙红色": 22,  # #FF6600
-    "深灰色(50%)": 23,  # #666666
-    "深紫色": 24,  # #660066
-    "蓝灰色": 25,  # #3366FF
-    "浅蓝色": 26,  # #99CCFF
-    "浅紫色": 27,  # #CC99FF
-    "浅青绿色": 28,  # #99FFFF
-    "浅绿色": 29,  # #CCFFCC
-    "浅黄色": 30,  # #FFFFCC
-    "浅橙红色": 31,  # #FFCC99
-    "玫瑰红": 32,  # #FF9999
-    "浅天蓝色": 33,  # #99CCFF
-    "浅海绿色": 34,  # #99FFCC
-    "浅草绿色": 35,  # #CCFF99
-    "浅柠檬黄": 36,  # #FFFF99
-    "浅珊瑚色": 37,  # #FFCC99
-    "浅玫瑰红": 38,  # #FF9999
-    "棕褐色": 39,  # #CC9966
-    "浅棕褐色": 40,  # #FFCC99
-    "浅橄榄色": 41,  # #CCCC99
-    "浅蓝灰色": 42,  # #9999FF
-    "浅灰绿色": 43,  # #99CC99
-    "金色": 44,  # #FFCC00
-    "浅橙黄色": 45,  # #FFCC66
-    "橙红色": 46,  # #FF6600
-    "深天蓝色": 47,  # #0066CC
-    "深海绿色": 48,  # #009966
-    "深草绿色": 49,  # #669900
-    "深柠檬黄": 50,  # #CCCC00
-    "深珊瑚色": 51,  # #FF9933
-    "深玫瑰红(暗)": 52,  # #CC6699
-    "深棕褐色": 53,  # #996633
-    "深橄榄色": 54,  # #666600
-    "深蓝灰色": 55,  # #333399
+    "深玫瑰红"     : 20,  # #FF99CC
+    "深金色"       : 21,  # #FFCC99
+    "深橙红色"     : 22,  # #FF6600
+    "深灰色(50%)"  : 23,  # #666666
+    "深紫色"       : 24,  # #660066
+    "蓝灰色"       : 25,  # #3366FF
+    "浅蓝色"       : 26,  # #99CCFF
+    "浅紫色"       : 27,  # #CC99FF
+    "浅青绿色"     : 28,  # #99FFFF
+    "浅绿色"       : 29,  # #CCFFCC
+    "浅黄色"       : 30,  # #FFFFCC
+    "浅橙红色"     : 31,  # #FFCC99
+    "玫瑰红"       : 32,  # #FF9999
+    "浅天蓝色"     : 33,  # #99CCFF
+    "浅海绿色"     : 34,  # #99FFCC
+    "浅草绿色"     : 35,  # #CCFF99
+    "浅柠檬黄"     : 36,  # #FFFF99
+    "浅珊瑚色"     : 37,  # #FFCC99
+    "浅玫瑰红"     : 38,  # #FF9999
+    "棕褐色"       : 39,  # #CC9966
+    "浅棕褐色"     : 40,  # #FFCC99
+    "浅橄榄色"     : 41,  # #CCCC99
+    "浅蓝灰色"     : 42,  # #9999FF
+    "浅灰绿色"     : 43,  # #99CC99
+    "金色"         : 44,  # #FFCC00
+    "浅橙黄色"     : 45,  # #FFCC66
+    "橙红色"       : 46,  # #FF6600
+    "深天蓝色"     : 47,  # #0066CC
+    "深海绿色"     : 48,  # #009966
+    "深草绿色"     : 49,  # #669900
+    "深柠檬黄"     : 50,  # #CCCC00
+    "深珊瑚色"     : 51,  # #FF9933
+    "深玫瑰红(暗)" : 52,  # #CC6699
+    "深棕褐色"     : 53,  # #996633
+    "深橄榄色"     : 54,  # #666600
+    "深蓝灰色"     : 55,  # #333399
 }
 
+def aggregate_by_column(data, group_by_col_name):
+    """
+    根据指定列名对二维表数据聚合：
+    - 数字列求和
+    - 字符串列用换行符拼接
+
+    :param data: 二维列表，第一行为表头
+    :param group_by_col_name: 要聚合的列名，如 "店长"
+    :return: 聚合后的二维列表
+    """
+    headers = data[0]
+    group_index = headers.index(group_by_col_name)
+    grouped = defaultdict(list)
+
+    # 按 group_by 列聚合行
+    for row in data[1:]:
+        key = row[group_index]
+        grouped[key].append(row)
+
+    result = [headers]
+
+    for key, rows in grouped.items():
+        agg_row = []
+        for col_idx in range(len(headers)):
+            col_values = [r[col_idx] for r in rows]
+            # 聚合字段
+            if col_idx == group_index:
+                agg_value = key
+            else:
+                # 尝试将值转为 float，如果成功就求和，否则拼接
+                try:
+                    nums = [float(v) for v in col_values if
+                            isinstance(v, (int, float)) or (isinstance(v, str) and v.strip() != '')]
+                    agg_value = sum(nums)
+                except ValueError:
+                    # 拼接字符串（去重可加 set）
+                    strings = [str(v).strip() for v in col_values if str(v).strip()]
+                    agg_value = '\n'.join(strings)
+            agg_row.append(agg_value)
+        result.append(agg_row)
+
+    return result
 
 def set_cell_prefix_red(cell, n, color_name):
     """
@@ -90,14 +136,56 @@ def set_cell_prefix_red(cell, n, color_name):
     except Exception as e:
         print(f"设置字体颜色失败: {e}")
 
+def wrap_column(sheet, columns=None, WrapText=True):
+    if columns is None:
+        return
+    used_range_col = sheet.range('A1').expand('right')
+    for j, cell in enumerate(used_range_col):
+        col = j + 1
+        col_name = index_to_column_name(col)
+        col_val = sheet.range(f'{col_name}1').value
+        if col_val is None:
+            continue
+        for c in columns:
+            if c in col_val:
+                log(f'设置[{c}] 换行 {WrapText}')
+                sheet.range(f'{col_name}:{col_name}').api.WrapText = WrapText
+
+def sort_by_column_excel(sheet, sort_col: str, has_header=True, order="desc"):
+    """
+    对整个表格按照某一列排序
 
-def sort_by_column(data, col_index, start_row=2, reverse=True):
-    if not data or start_row >= len(data):
+    :param sheet: xlwings 的 sheet 对象
+    :param sort_col: 排序依据的列（如 'D'）
+    :param has_header: 是否有表头（默认 True）
+    :param order: 'asc' 升序，'desc' 降序
+    """
+    # 找到表格的最后一行和列
+    last_cell = sheet.used_range.last_cell
+    rng = sheet.range((1, 1), (last_cell.row, last_cell.column))
+
+    # 排序依据列
+    col_index = ord(sort_col.upper()) - ord('A') + 1
+    key = sheet.range((2 if has_header else 1, col_index)).api
+
+    # 排序顺序
+    order_val = 1 if order == "asc" else 2
+
+    # 调用 Excel 的 Sort 方法
+    rng.api.Sort(
+        Key1=key,
+        Order1=order_val,
+        Orientation=1,
+        Header=1 if has_header else 0
+    )
+
+def sort_by_column(data, col_index, header_rows=2, reverse=True):
+    if not data or header_rows >= len(data):
         return data
 
     try:
-        header = data[:start_row]
-        new_data_sorted = data[start_row:]
+        header = data[:header_rows]
+        new_data_sorted = data[header_rows:]
 
         def get_key(row):
             value = row[col_index]
@@ -114,7 +202,6 @@ def sort_by_column(data, col_index, start_row=2, reverse=True):
         print(f"Error: Column index {col_index} out of range")
         return data
 
-
 def column_exists(sheet, column_name, header_row=1):
     """
     检查工作表中是否存在指定列名
@@ -128,7 +215,6 @@ def column_exists(sheet, column_name, header_row=1):
 
     return column_name in header_values
 
-
 def merge_by_column_v2(sheet, column_name, other_columns):
     log('正在处理合并单元格')
     # 最好放到 open_excel 后面,不然容易出错
@@ -137,38 +223,88 @@ def merge_by_column_v2(sheet, column_name, other_columns):
         log(f'未找到合并的列名: {column_name}')
         return
 
-    data = sheet.range(f'{col_letter}1').expand('table').value
-    # col_index = column_name_to_index(col_letter)
-    start_row = 1
-    merge_ranges = []  # 用来存储所有待合并的单元格范围
+    # 更安全的数据获取方式，确保获取完整的数据范围
+    last_row = get_last_row(sheet, col_letter)
+    data = sheet.range(f'{col_letter}1:{col_letter}{last_row}').value
+
+    # 确保data是列表格式
+    if not isinstance(data, list):
+        data = [data]
+
+    log(f'数据范围: {col_letter}1:{col_letter}{last_row}, 数据长度: {len(data)}')
 
-    # 缓存其他列的列号
-    other_columns_index = {}
+    start_row = 2  # 从第2行开始，跳过表头
+    merge_row_ranges = []  # 用来存储需要合并的行范围 (start_row, end_row)
+
+    # 获取所有需要合并的列
+    all_columns = [col_letter]  # 主列
     for col in other_columns:
         col_name = find_column_by_data(sheet, 1, col)
         if col_name:
-            other_columns_index[col_name] = column_name_to_index(col_name)
+            all_columns.append(col_name)
 
-    for row in range(2, len(data) + 1):
-        log(f'查找 {row}/{len(data)}')
-        if data[row - 1][0] != data[row - 2][0]:
-            if row - start_row > 1:
-                # 将合并范围加入列表
-                merge_ranges.append((col_letter, start_row, row - 1))
-                for col_name, col_index in other_columns_index.items():
-                    merge_ranges.append((col_name, start_row, row - 1))
+    log(f'需要合并的列: {all_columns}')
+
+    # 遍历数据行，从第3行开始比较（因为第1行是表头，第2行是第一个数据行）
+    for row in range(3, len(data) + 1):
+        log(f'查找 {row}/{len(data)}, 当前值: {data[row - 1] if row - 1 < len(data) else "超出范围"}, 前一个值: {data[row - 2] if row - 2 < len(data) else "超出范围"}')
+
+        # 检查值是否发生变化
+        if row <= len(data) and data[row - 1] != data[row - 2]:
+            # 值发生变化，处理前一组
+            end_row = row - 1
+            log(f'添加合并范围: {start_row} 到 {end_row}')
+            merge_row_ranges.append((start_row, end_row))
             start_row = row
 
-    if len(data) - start_row > 1:
-        merge_ranges.append((col_letter, start_row, len(data)))
-        for col_name, col_index in other_columns_index.items():
-            merge_ranges.append((col_name, start_row, len(data)))
+    # 处理最后一组数据（循环结束后，start_row 到数据末尾）
+    if start_row <= len(data):
+        end_row = len(data)
+        log(f'处理最后一组: {start_row} 到 {end_row}')
+        merge_row_ranges.append((start_row, end_row))
 
-    # 批量合并单元格
-    for col_name, start, end in merge_ranges:
-        log(f'处理 {col_name}{start}:{col_name}{end} merge')
-        sheet.range(f'{col_name}{start}:{col_name}{end}').merge()
+    log(f'行合并范围: {merge_row_ranges}')
 
+    # 对每个行范围，在所有指定列中执行合并
+    for start_row, end_row in merge_row_ranges:
+        if start_row < end_row:  # 只有当开始行小于结束行时才合并（多行）
+            for col_name in all_columns:
+                try:
+                    cell_range = sheet.range(f'{col_name}{start_row}:{col_name}{end_row}')
+                    
+                    # 验证：检查范围内的值是否都相同
+                    values = cell_range.value
+                    if not isinstance(values, list):
+                        values = [values]
+                    
+                    # 检查是否所有值都相同（忽略 None）
+                    non_none_values = [v for v in values if v is not None]
+                    if non_none_values and len(set(non_none_values)) > 1:
+                        log(f'警告：{col_name}{start_row}:{col_name}{end_row} 包含不同的值，跳过合并: {set(non_none_values)}')
+                        continue
+                    
+                    log(f'处理 {col_name}{start_row}:{col_name}{end_row} merge')
+                    
+                    # 保存第一个单元格的值
+                    first_cell_value = sheet.range(f'{col_name}{start_row}').value
+                    
+                    # 先清空所有单元格（避免多行文本导致的合并问题）
+                    cell_range.value = None
+                    
+                    # 执行合并
+                    cell_range.merge()
+                    
+                    # 恢复第一个单元格的值
+                    cell_range.value = first_cell_value
+                    
+                except Exception as e:
+                    log(f'合并失败 {col_name}{start_row}:{col_name}{end_row}: {e}')
+                    # 继续处理其他列
+                    continue
+        elif start_row == end_row:
+            log(f'单行数据无需合并: {start_row} 到 {end_row}')
+        else:
+            log(f'跳过无效合并范围: {start_row} 到 {end_row}')
 
 def merge_by_column(sheet, column_name, other_columns):
     log('正在处理合并单元格')
@@ -198,7 +334,6 @@ def merge_by_column(sheet, column_name, other_columns):
             if col_name is not None:
                 sheet.range(f'{col_name}{start_row}:{col_name}{len(data)}').merge()
 
-
 def merge_column_v2(sheet, columns):
     if columns is None:
         return
@@ -229,7 +364,6 @@ def merge_column_v2(sheet, columns):
         log(f'处理 {col_letter}{start}:{col_letter}{end} merge')
         sheet.range(f'{col_letter}{start}:{col_letter}{end}').merge()
 
-
 # 按列相同值合并
 def merge_column(sheet, columns):
     # 最后放到 open_excel 后面,不然容易出错
@@ -252,7 +386,6 @@ def merge_column(sheet, columns):
         if len(data) - start_row > 1:
             sheet.range(f'{col_letter}{start_row}:{col_letter}{len(data)}').merge()
 
-
 def remove_excel_columns(sheet, columns):
     # 获取第一行(标题行)的所有值
     header_row = sheet.range('1:1').value
@@ -276,7 +409,6 @@ def remove_excel_columns(sheet, columns):
     print(f"成功移除列: {columns_to_remove}")
     return True
 
-
 def delete_sheet_if_exists(wb, sheet_name):
     """
     如果工作簿中存在指定名称的工作表，则将其删除。
@@ -290,11 +422,11 @@ def delete_sheet_if_exists(wb, sheet_name):
     sheet_names = [s.name for s in wb.sheets]
     if sheet_name in sheet_names:
         wb.sheets[sheet_name].delete()
+        wb.save()
         print(f"已删除 Sheet: {sheet_name}")
     else:
         print(f"Sheet 不存在: {sheet_name}")
 
-
 # 水平对齐：
 # -4108：居中
 # -4131：左对齐
@@ -316,7 +448,6 @@ def index_to_column_name(index):
         index = index // 26
     return column_name
 
-
 # # 示例：将列索引转换为列名
 # log(index_to_column_name(1))   # 输出: 'A'
 # log(index_to_column_name(26))  # 输出: 'Z'
@@ -334,7 +465,6 @@ def column_name_to_index(column_name):
         index = index * 26 + (ord(char.upper()) - 64)
     return index - 1
 
-
 # # 示例：将列名转换为列索引
 # log(column_name_to_index('A'))   # 输出: 1
 # log(column_name_to_index('Z'))   # 输出: 26
@@ -361,7 +491,6 @@ def find_row_by_data(sheet, column, target_value):
     # 如果未找到，返回 None
     return None
 
-
 def find_column_by_data(sheet, row, target_value):
     """
     查找指定数据在某一行中第一次出现的列名，包括隐藏的列。
@@ -382,7 +511,6 @@ def find_column_by_data(sheet, row, target_value):
 
     return None  # 未找到返回 None
 
-
 def find_column_by_data_old(sheet, row, target_value):
     """
     查找指定数据在某一行中第一次出现的列名。
@@ -404,7 +532,6 @@ def find_column_by_data_old(sheet, row, target_value):
     # 如果未找到，返回 None
     return None
 
-
 def set_print_area(sheet, print_range, pdf_path=None, fit_to_width=True, landscape=False):
     """
     设置指定sheet的打印区域和打印布局为适合A4宽度打印。
@@ -453,12 +580,10 @@ def set_print_area(sheet, print_range, pdf_path=None, fit_to_width=True, landsca
         sheet.to_pdf(path=pdf_path)
         log(f"PDF已成功生成：{pdf_path}")
 
-
 def minimize(app):
     # 让 Excel 窗口最小化
     app.api.WindowState = -4140  # -4140 对应 Excel 中的 xlMinimized 常量
 
-
 def insert_fixed_scale_image_v2(sheet, cell, image_path):
     """
     将图片插入到指定单元格中，自动缩放以适应单元格尺寸，但保持宽高比例不变。
@@ -521,7 +646,6 @@ def insert_fixed_scale_image_v2(sheet, cell, image_path):
 
     return None
 
-
 def insert_fixed_scale_image(sheet, cell, image_path, scale=1.0):
     """
     按固定比例放大图片并插入到单元格
@@ -559,12 +683,11 @@ def insert_fixed_scale_image(sheet, cell, image_path, scale=1.0):
 
     return None
 
-
-def InsertImageV2(app, wb, sheet, columns=None, platform='shein', img_width=150, img_save_key=None, dir_name=None):
+def InsertImageV2(sheet, columns=None, platform='shein', img_width=150, img_save_key=None, dir_name=None, cell_height_with_img=False, start_row=2):
     if not columns:
         return
 
-    minimize(app)
+    minimize(sheet.book.app)
 
     # 清空所有图片
     clear_all_pictures(sheet)
@@ -591,10 +714,10 @@ def InsertImageV2(app, wb, sheet, columns=None, platform='shein', img_width=150,
 
     img_key_letter = find_column_by_data(sheet, 1, img_save_key)
 
-    # 预计算所有单元格的合并区域信息 (优化点1)
+    # 阶段1：调整所有单元格尺寸 (优化点1)
     area_map = {}
-    for row in range(2, last_row + 1):
-        log(f'计算 {row}/{last_row}')  # 如果数据量非常大，这里的日志会影响性能，可以考虑优化
+    for row in range(start_row, last_row + 1):
+        log(f'计算 {row}/{last_row}')
         for col_letter in col_letter_map.values():
             cell_ref = f'{col_letter}{row}'
             cell_range = sheet.range(cell_ref)
@@ -605,33 +728,50 @@ def InsertImageV2(app, wb, sheet, columns=None, platform='shein', img_width=150,
                 cell_address = cell_range.address
 
             if cell_address not in area_map:
-                # 计算合并区域的宽高和位置
-                cell_width = cell_range.width
-                cell_height = cell_range.height
-
-                # 调整列宽和行高
-                if cell_width < img_width:
-                    cell_range.column_width = img_width / 6.1
-
-                # 这一行暂时先自动控制宽度
+                # 调整列宽
                 cell_range.column_width = img_width / 6.1
 
-                if cell_height < img_width:
-                    cell_range.row_height = max(150 / 8, img_width / cell_range.rows.count)
+                # 调整行高
+                if cell_range.height < img_width:
+                    if cell_range.merge_cells:
+                        # 合并单元格：为每一行设置高度
+                        rows_count = cell_range.rows.count
+                        per_row_height = img_width / rows_count
+                        for single_row in cell_range.rows:
+                            single_row.row_height = max(per_row_height, 150 / 8)
+                    else:
+                        cell_range.row_height = max(img_width, 150 / 8)
 
+                if cell_height_with_img:
+                    if cell_range.merge_cells:
+                        rows_count = cell_range.rows.count
+                        for single_row in cell_range.rows:
+                            single_row.row_height = img_width / rows_count
+                    else:
+                        cell_range.row_height = img_width
+                
+                # 重新读取调整后的宽高
+                if cell_range.merge_cells:
+                    cell_range = sheet.range(cell_ref).merge_area
+                else:
+                    cell_range = sheet.range(cell_ref)
+                
                 # 计算居中位置
-                top = cell_range.top + (cell_range.height - img_width) / 2
-                left = cell_range.left + (cell_range.width - img_width) / 2
+                actual_width = cell_range.width
+                actual_height = cell_range.height
+                actual_img_size = img_width - 4
+                top = cell_range.top + (actual_height - actual_img_size) / 2 - 2
+                left = cell_range.left + (actual_width - actual_img_size) / 2 - 2
 
                 area_map[cell_address] = {
-                    'top': top,
-                    'left': left,
-                    'width': img_width,
-                    'cell_list': [c.address for c in cell_range]
+                    'top'      : top,
+                    'left'     : left,
+                    'width'    : img_width,
+                    'cell_list': [c.address for c in cell_range] if cell_range.merge_cells else [cell_address]
                 }
 
     # 处理图片插入 (优化点2)
-    for row in range(2, last_row + 1):
+    for row in range(start_row, last_row + 1):
         for img_col_name, col_letter in col_letter_map.items():
             cell_ref = f'{col_letter}{row}'
             cell_range = sheet.range(cell_ref)
@@ -684,6 +824,237 @@ def InsertImageV2(app, wb, sheet, columns=None, platform='shein', img_width=150,
             else:
                 log(f'图片地址不存在 [{img_col_name}] : 第{row}行')
 
+def InsertImageV3(sheet, columns=None, platform='shein', img_widths=None, img_save_key=None, dir_name=None, cell_height_with_img=False, start_row=2):
+    """
+    V3版本：支持一次性插入多列图片，每列可以设置不同的宽度
+    
+    Args:
+        sheet: Excel工作表对象
+        columns: 图片列名列表，如 ['SKC图片', 'SKU图片']
+        platform: 平台名称，如 'shein'
+        img_widths: 图片宽度列表，与columns对应，如 [90, 60]
+        img_save_key: 图片保存时的key列
+        dir_name: 图片保存目录名
+        cell_height_with_img: 是否根据图片调整单元格高度
+        start_row: 开始行号，默认为2
+    """
+    if not columns:
+        return
+    
+    # 如果没有提供宽度列表，使用默认宽度150
+    if not img_widths:
+        img_widths = [150] * len(columns)
+    
+    # 确保宽度列表长度与列名列表一致
+    if len(img_widths) != len(columns):
+        raise ValueError(f"img_widths长度({len(img_widths)})必须与columns长度({len(columns)})一致")
+
+    minimize(sheet.book.app)
+
+    # 只清空一次所有图片
+    clear_all_pictures(sheet)
+
+    # 获取每列图片列的列号，并批量下载图片
+    col_letter_map = {}
+    col_width_map = {}  # 存储每列对应的宽度
+    
+    for idx, img_col in enumerate(columns):
+        col_letter = find_column_by_data(sheet, 1, img_col)
+        if col_letter is not None:
+            col_letter_map[img_col] = col_letter
+            col_width_map[col_letter] = img_widths[idx]
+            # 下载图片
+            log(f'批量下载图片: {img_col} => {col_letter} (宽度: {img_widths[idx]})')
+            last_row = get_last_row(sheet, col_letter)
+            images = sheet.range(f'{col_letter}2:{col_letter}{last_row}').value
+            images = images if isinstance(images, list) else [images]
+            download_images_concurrently(images, platform)
+
+    # 任意一个列作为主参考列，用来确定行数
+    if not col_letter_map:
+        return
+
+    ref_col_letter = next(iter(col_letter_map.values()))
+    last_row = get_last_row(sheet, ref_col_letter)
+
+    img_key_letter = find_column_by_data(sheet, 1, img_save_key)
+
+    # 阶段1：收集每个单元格需要的尺寸要求
+    cell_size_requirements = {}  # {cell_address: {'width': max_width, 'height': max_height, 'merge': is_merge}}
+    
+    for row in range(start_row, last_row + 1):
+        for col_letter in col_letter_map.values():
+            cell_ref = f'{col_letter}{row}'
+            cell_range = sheet.range(cell_ref)
+            cell_address = cell_range.address
+            img_width = col_width_map[col_letter]
+            
+            if cell_range.merge_cells:
+                cell_range = cell_range.merge_area
+                cell_address = cell_range.address
+            
+            # 记录每个单元格需要的最大尺寸
+            if cell_address not in cell_size_requirements:
+                cell_size_requirements[cell_address] = {
+                    'width': img_width,
+                    'height': img_width,
+                    'cell_range': cell_range,
+                    'merge': cell_range.merge_cells
+                }
+            else:
+                # 取最大值
+                cell_size_requirements[cell_address]['width'] = max(
+                    cell_size_requirements[cell_address]['width'], img_width
+                )
+                cell_size_requirements[cell_address]['height'] = max(
+                    cell_size_requirements[cell_address]['height'], img_width
+                )
+    
+    # 阶段2：统一调整所有单元格的宽高（按列分别处理）
+    log(f'调整单元格尺寸...')
+    adjusted_cells = {}  # 记录已调整的单元格，避免重复调整
+    
+    for col_letter in col_letter_map.values():
+        img_width = col_width_map[col_letter]
+        
+        for row in range(start_row, last_row + 1):
+            cell_ref = f'{col_letter}{row}'
+            cell_range = sheet.range(cell_ref)
+            cell_address = cell_range.address
+            
+            if cell_range.merge_cells:
+                cell_range = cell_range.merge_area
+                cell_address = cell_range.address
+            
+            # 调整列宽（按原来的逻辑，每列都调整）
+            if cell_range.width < img_width:
+                cell_range.column_width = img_width / 6.1
+            # 这一行暂时先自动控制宽度
+            cell_range.column_width = img_width / 6.1
+            
+            # 行高只调整一次（使用最大需求）
+            if cell_address not in adjusted_cells:
+                adjusted_cells[cell_address] = True
+                required_height = cell_size_requirements[cell_address]['height']
+                
+                # 调整行高
+                if cell_range.height < required_height:
+                    if cell_range.merge_cells:
+                        # 合并单元格：为每一行设置高度
+                        rows_count = cell_range.rows.count
+                        per_row_height = required_height / rows_count
+                        for single_row in cell_range.rows:
+                            single_row.row_height = max(per_row_height, 150 / 8)
+                    else:
+                        cell_range.row_height = max(required_height, 150 / 8)
+                
+                if cell_height_with_img:
+                    if cell_range.merge_cells:
+                        rows_count = cell_range.rows.count
+                        for single_row in cell_range.rows:
+                            single_row.row_height = required_height / rows_count
+                    else:
+                        cell_range.row_height = required_height
+    
+    # 阶段3：计算所有图片的位置
+    area_map = {}
+    for row in range(start_row, last_row + 1):
+        log(f'计算位置 {row}/{last_row}')
+        for col_letter in col_letter_map.values():
+            cell_ref = f'{col_letter}{row}'
+            cell_range = sheet.range(cell_ref)
+            cell_address = cell_range.address
+            img_width = col_width_map[col_letter]
+            
+            if cell_range.merge_cells:
+                cell_range = cell_range.merge_area
+                cell_address = cell_range.address
+            
+            # 重新读取调整后的宽高
+            actual_width = cell_range.width
+            actual_height = cell_range.height
+            
+            # 计算该列图片的居中位置
+            # 图片实际大小是 img_width-4，插入时偏移+2，所以这里-2补偿
+            actual_img_size = img_width - 4
+            top = cell_range.top + (actual_height - actual_img_size) / 2 - 2
+            left = cell_range.left + (actual_width - actual_img_size) / 2 - 2
+            
+            # 每个列都单独保存位置
+            area_map[f'{cell_address}_{col_letter}'] = {
+                'top': top,
+                'left': left,
+                'width': img_width,
+                'cell_address': cell_address,
+                'cell_list': [c.address for c in cell_range] if cell_range.merge_cells else [cell_address]
+            }
+
+    # 阶段4：插入图片
+    for row in range(start_row, last_row + 1):
+        for img_col_name, col_letter in col_letter_map.items():
+            cell_ref = f'{col_letter}{row}'
+            cell_range = sheet.range(cell_ref)
+            original_address = cell_range.address
+
+            if cell_range.merge_cells:
+                cell_range = cell_range.merge_area
+                cell_address = cell_range.address
+            else:
+                cell_address = original_address
+
+            # 检查是否是合并单元格的非首单元格（跳过）
+            area_key = f'{cell_address}_{col_letter}'
+            if area_key not in area_map:
+                continue
+                
+            area_info = area_map[area_key]
+            
+            # 对于合并单元格，只在第一个单元格处理
+            if cell_range.merge_cells:
+                # 获取合并区域的第一个单元格地址
+                first_cell_in_merge = area_info['cell_list'][0] if area_info['cell_list'] else cell_address
+                # 如果当前单元格不是合并区域的第一个单元格，跳过
+                if original_address != first_cell_in_merge:
+                    continue
+
+            # 使用预计算的位置信息
+            top = area_info['top']
+            left = area_info['left']
+            width = area_info['width']
+
+            # 获取图片链接
+            if cell_range.merge_cells:
+                img_url = cell_range.value[0]
+            else:
+                img_url = cell_range.value
+
+            if img_url:
+                if img_key_letter is not None:
+                    image_dir = Path(f'{os.getenv('auto_dir')}/image') / dir_name
+                    extension = Path(img_url).suffix
+                    filename = str(sheet.range(f'{img_key_letter}{row}').value)
+                    img_save_path = image_dir / f"{sanitize_filename(filename)}{extension}"
+                else:
+                    img_save_path = None
+
+                img_path = download_img_v2(img_url, platform, img_save_path)
+                log(f'插入图片 {sheet.name} [{img_col_name}] {row}/{last_row} {img_path}')
+                if not img_path:
+                    log('跳过:', img_path, img_url)
+                    continue
+                cell_value = cell_range.value
+
+                # 插入图片
+                try:
+                    # 使用预计算的位置直接插入图片
+                    sheet.pictures.add(img_path, top=top + 2, left=left + 2, width=width - 4, height=width - 4)
+                    cell_range.value = None
+                except Exception as e:
+                    # 插入图片失败恢复链接地址
+                    cell_range.value = cell_value
+                    send_exception()
+            else:
+                log(f'图片地址不存在 [{img_col_name}] : 第{row}行')
 
 def download_images_concurrently(image_urls, platform='shein', img_save_dir=None):
     # 使用线程池执行并发下载
@@ -692,21 +1063,23 @@ def download_images_concurrently(image_urls, platform='shein', img_save_dir=None
         results = list(executor.map(lambda url: download_img_v2(url, platform, img_save_path=img_save_dir), image_urls))
     return results
 
-
 def download_img_by_chrome(image_url, save_name):
-    with sync_playwright() as p:
-        browser = p.chromium.launch(headless=True)  # 运行时可以看到浏览器
-        context = browser.new_context()
-        page = context.new_page()
-        # 直接通过Playwright下载图片
-        response = page.request.get(image_url)
-        with open(save_name, 'wb') as f:
-            f.write(response.body())  # 将下载的内容保存为文件
-        log(f"图片已通过chrome下载并保存为:{save_name}")
-        # 关闭浏览器
-        browser.close()
-    return save_name
-
+    try:
+        with sync_playwright() as p:
+            browser = p.chromium.launch(headless=True)  # 运行时可以看到浏览器
+            context = browser.new_context()
+            page = context.new_page()
+            # 直接通过Playwright下载图片
+            response = page.request.get(image_url)
+            with open(save_name, 'wb') as f:
+                f.write(response.body())  # 将下载的内容保存为文件
+            log(f"图片已通过chrome下载并保存为:{save_name}")
+            # 关闭浏览器
+            browser.close()
+            return save_name
+    except:
+        send_exception()
+        return None
 
 def download_img_v2(image_url, platform='shein', img_save_path=None):
     image_url = add_https(image_url)
@@ -745,8 +1118,8 @@ def download_img_v2(image_url, platform='shein', img_save_path=None):
     #     return False
 
     headers = {
-        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
-        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
+        "User-Agent"     : "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36",
+        "Accept"         : "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
         "Accept-Encoding": "gzip, deflate",
         "Accept-Language": "zh-CN,zh;q=0.9"
     }
@@ -779,7 +1152,6 @@ def download_img_v2(image_url, platform='shein', img_save_path=None):
 
     return file_path
 
-
 # 插入图片函数 注意windows中这个路径反斜杠要是这样的才能插入成功
 # C:\Users\Administrator/Desktop/auto/sku_img\K-CPYZB005-1_1734316546.png
 def insert_cell_image(sheet, cell, file_path, img_width=120):
@@ -825,7 +1197,6 @@ def insert_cell_image(sheet, cell, file_path, img_width=120):
         log(f'插入图片失败: {e}, {file_path}')
         send_exception()
 
-
 # 插入图片函数 注意windows中这个路径反斜杠要是这样的才能插入成功
 # C:\Users\Administrator/Desktop/auto/sku_img\K-CPYZB005-1_1734316546.png
 def insert_image_from_local(sheet, cell, file_path, cell_width=90, cell_height=90):
@@ -864,7 +1235,6 @@ def insert_image_from_local(sheet, cell, file_path, cell_width=90, cell_height=9
     except Exception as e:
         log(f'插入图片失败: {e}, {file_path}')
 
-
 # 插入图片函数 注意windows中这个路径反斜杠要是这样的才能插入成功
 # C:\Users\Administrator/Desktop/auto/sku_img\K-CPYZB005-1_1734316546.png
 def insert_skc_image_from_local(sheet, cell, file_path):
@@ -897,7 +1267,6 @@ def insert_skc_image_from_local(sheet, cell, file_path):
     except Exception as e:
         log(f'插入图片失败: {e}')
 
-
 # # 设置 A 列和第 1 行为接近 100x100 的正方形
 # set_square_cells(sheet, 'A', 1, 100)
 
@@ -916,35 +1285,34 @@ def clear_all_pictures(sheet):
         send_exception()
         log(f"清空图片失败: {e}")
 
-
 def get_excel_format(sheet, cell_range):
     rng = sheet.range(cell_range)
 
     format_settings = {
         "numberFormat": rng.number_format,
-        "font": {
-            "name": rng.api.Font.Name,
-            "size": rng.api.Font.Size,
-            "bold": rng.api.Font.Bold,
+        "font"        : {
+            "name"  : rng.api.Font.Name,
+            "size"  : rng.api.Font.Size,
+            "bold"  : rng.api.Font.Bold,
             "italic": rng.api.Font.Italic,
-            "color": rng.api.Font.Color
+            "color" : rng.api.Font.Color
         },
-        "alignment": {
+        "alignment"   : {
             "horizontalAlignment": rng.api.HorizontalAlignment,
-            "verticalAlignment": rng.api.VerticalAlignment,
-            "wrapText": rng.api.WrapText
+            "verticalAlignment"  : rng.api.VerticalAlignment,
+            "wrapText"           : rng.api.WrapText
         },
-        "borders": []
+        "borders"     : []
     }
 
     # 获取所有边框设置（Excel 有 8 种边框）
     for index in range(5, 13):
         border = rng.api.Borders(index)
         format_settings["borders"].append({
-            "index": index,
+            "index"    : index,
             "lineStyle": border.LineStyle,
-            "color": border.Color,
-            "weight": border.Weight
+            "color"    : border.Color,
+            "weight"   : border.Weight
         })
 
     # 获取背景色
@@ -958,7 +1326,6 @@ def get_excel_format(sheet, cell_range):
 
     return json.dumps(format_settings, indent=2)
 
-
 def set_excel_format(sheet, cell_range, json_setting):
     settings = json.loads(json_setting)
 
@@ -1017,7 +1384,6 @@ def set_excel_format(sheet, cell_range, json_setting):
     if "formulaHidden" in settings:
         rng.api.FormulaHidden = settings["formulaHidden"]
 
-
 # # 获取 A1 单元格格式
 # json_format = get_excel_format(sheet, "A1")
 # log("Original Format:", json_format)
@@ -1056,7 +1422,6 @@ def get_unique_values(sheet, column, start_row, end_row=None):
     # unique_values = get_unique_values(sheet, 'A', 2)
     # log(unique_values)
 
-
 def get_unique_values_by_row(sheet, row, start_col, end_col=None):
     """
     获取指定行从指定列开始的不重复值列表，确保读取的值与 Excel 中显示的内容完全一致。
@@ -1088,7 +1453,6 @@ def get_unique_values_by_row(sheet, row, start_col, end_col=None):
     # 获取第 2 行从 A 列开始的不重复值
     # unique_values = get_unique_values_by_row(sheet, 2, 'A')
 
-
 def find_rows_by_criteria(sheet, col, search_text, match_type='equals'):
     """
     在指定列中查找符合条件的数据所在行。
@@ -1140,7 +1504,6 @@ def find_rows_by_criteria(sheet, col, search_text, match_type='equals'):
     # result_negative_col = find_rows_by_criteria(sheet, -1, 'xyz', match_type='equals')
     # log("倒数第一列匹配结果:", result_negative_col)
 
-
 def find_columns_by_criteria(sheet, row, search_text, match_type='equals'):
     """
     在指定行中查找符合条件的数据所在列。
@@ -1186,12 +1549,10 @@ def find_columns_by_criteria(sheet, row, search_text, match_type='equals'):
     # result_negative_row = find_columns_by_criteria(sheet, -1, 'xyz', match_type='equals')
     # log("倒数第一行匹配结果:", result_negative_row)
 
-
 def check_data(data):
     for row in data:
         log(len(row), row)
 
-
 def write_data(excel_path, sheet_name, data, format_to_text_colunm=None):
     app, wb, sheet = open_excel(excel_path, sheet_name)
     # 清空工作表中的所有数据
@@ -1205,9 +1566,8 @@ def write_data(excel_path, sheet_name, data, format_to_text_colunm=None):
     wb.save()
     close_excel(app, wb)
 
-
-def colorize_by_field(app, wb, sheet, field):
-    minimize(app)
+def colorize_by_field(sheet, field):
+    minimize(sheet.book.app)
     # 读取数据
     field_column = find_column_by_data(sheet, 1, field)  # 假设 SPU 在 C 列
     if field_column is None:
@@ -1228,6 +1588,72 @@ def colorize_by_field(app, wb, sheet, field):
         row_range.color = bg_color  # 应用背景色
         sheet.range(f"A{row}").api.Font.Bold = True  # 让店铺名称加粗
 
+def colorize_by_field_v2(sheet, field):
+    """
+    改进版：按指定字段为行着色，正确处理合并单元格
+    
+    Args:
+        sheet: Excel工作表对象
+        field: 用于分组着色的字段名（列名）
+    """
+    minimize(sheet.book.app)
+    
+    # 查找字段所在的列
+    field_column = find_column_by_data(sheet, 1, field)
+    if field_column is None:
+        log(f'未找到字段列: {field}')
+        return
+    
+    log(f'按字段 {field} (列 {field_column}) 着色')
+    
+    # 获取最后一行和最后一列
+    last_row = get_last_row(sheet, field_column)
+    max_column_letter = get_max_column_letter(sheet)
+    
+    # 记录字段值对应的颜色
+    field_color_map = {}
+    last_field_value = None  # 记录上一个非空值
+    
+    # 从第2行开始遍历（跳过表头）
+    for row in range(2, last_row + 1):
+        # 读取当前行的字段值
+        cell = sheet.range(f'{field_column}{row}')
+        current_value = cell.value
+        
+        # 如果是合并单元格的非首单元格，值可能为 None，使用上一个非空值
+        if current_value is None or current_value == '':
+            # 检查是否是合并单元格
+            if cell.merge_cells:
+                # 使用合并区域的值
+                merge_area = cell.merge_area
+                current_value = merge_area.value
+                if isinstance(current_value, (list, tuple)):
+                    current_value = current_value[0] if current_value else None
+            
+            # 如果仍然为空，使用上一个非空值
+            if current_value is None or current_value == '':
+                current_value = last_field_value
+        else:
+            # 更新上一个非空值
+            last_field_value = current_value
+        
+        # 跳过空值
+        if current_value is None or current_value == '':
+            continue
+        
+        # 为新的字段值分配颜色
+        if current_value not in field_color_map:
+            field_color_map[current_value] = random_color()
+        
+        # 应用背景色到整行
+        bg_color = field_color_map[current_value]
+        row_range = sheet.range(f'A{row}:{max_column_letter}{row}')
+        row_range.color = bg_color
+        
+        # 可选：让第一列加粗（店铺信息等）
+        # sheet.range(f'A{row}').api.Font.Bold = True
+    
+    log(f'着色完成，共 {len(field_color_map)} 个不同的 {field} 值')
 
 def add_borders(sheet, lineStyle=1):
     log('添加边框')
@@ -1248,7 +1674,6 @@ def add_borders(sheet, lineStyle=1):
     range_to_border.api.Borders(3).LineStyle = lineStyle  # 内部左边框
     range_to_border.api.Borders(4).LineStyle = lineStyle  # 内部右边框
 
-
 def add_range_border(sheet, coor_A=(1, 1), coor_B=(1, 1), lineStyle=1):
     range_to_border = sheet.range(coor_A, coor_B)  # 定义范围
 
@@ -1264,7 +1689,6 @@ def add_range_border(sheet, coor_A=(1, 1), coor_B=(1, 1), lineStyle=1):
     range_to_border.api.Borders(3).LineStyle = lineStyle  # 内部左边框
     range_to_border.api.Borders(4).LineStyle = lineStyle  # 内部右边框
 
-
 def open_excel(excel_path, sheet_name='Sheet1'):
     try:
         # 创建新实例
@@ -1321,7 +1745,6 @@ def open_excel(excel_path, sheet_name='Sheet1'):
         # wxwork.notify_error_msg(f'打开 Excel 失败: {traceback.format_exc()}')
         return None, None, None
 
-
 def close_excel(app, wb):
     if wb is not None:
         wb.save()
@@ -1329,7 +1752,6 @@ def close_excel(app, wb):
     if app is not None:
         app.quit()
 
-
 # 获取某列最后非空行
 def get_last_row(sheet, column):
     last_row = sheet.range(column + str(sheet.cells.last_cell.row)).end('up').row
@@ -1340,38 +1762,32 @@ def get_last_row(sheet, column):
         last_row = cell.merge_area.last_cell.row
     return last_row
 
-
 # 获取最后一列字母
 def get_last_col(sheet):
     # # 获取最后一行的索引
     last_col = index_to_column_name(sheet.range('A1').end('right').column)  # 里面是索引 返回最后一列 如 C
     return last_col
 
-
 # 获取最大列名字母
 def get_max_column_letter(sheet):
     """获取当前 sheet 中最大有数据的列的列名（如 'A', 'B', ..., 'Z', 'AA', 'AB'）"""
     last_col = sheet.used_range.last_cell.column  # 获取最大列索引
     return xw.utils.col_name(last_col)  # 将索引转换为列名
 
-
 # 随机生成颜色
 def random_color():
     return (random.randint(180, 255), random.randint(180, 255), random.randint(180, 255))  # 亮色背景
 
-
 def get_contrast_text_color(rgb):
     """根据背景色亮度返回适合的字体颜色（黑色或白色）"""
     r, g, b = rgb
     brightness = r * 0.299 + g * 0.587 + b * 0.114  # 亮度计算公式
     return (0, 0, 0) if brightness > 186 else (255, 255, 255)  # 186 是经验值
 
-
 def rgb_to_long(r, g, b):
     """将 RGB 颜色转换为 Excel Long 类型"""
     return r + (g * 256) + (b * 256 * 256)
 
-
 def read_excel_to_json(file_path, sheet_name="Sheet1"):
     app, wb, sheet = open_excel(file_path, sheet_name)
 
@@ -1409,20 +1825,20 @@ def read_excel_to_json(file_path, sheet_name="Sheet1"):
                 diagonal_down_info = {"style": diagonal_down.LineStyle, "color": diagonal_down.Color}
 
             cell_info = {
-                "value": cell.value,
-                "color": cell.color,
-                "font_name": cell.api.Font.Name,
-                "font_size": cell.api.Font.Size,
-                "bold": cell.api.Font.Bold,
-                "italic": cell.api.Font.Italic,
-                "font_color": cell.api.Font.Color,
+                "value"           : cell.value,
+                "color"           : cell.color,
+                "font_name"       : cell.api.Font.Name,
+                "font_size"       : cell.api.Font.Size,
+                "bold"            : cell.api.Font.Bold,
+                "italic"          : cell.api.Font.Italic,
+                "font_color"      : cell.api.Font.Color,
                 "horizontal_align": cell.api.HorizontalAlignment,
-                "vertical_align": cell.api.VerticalAlignment,
-                "number_format": cell.api.NumberFormat,
-                "border": {
-                    "left": {"style": cell.api.Borders(1).LineStyle, "color": cell.api.Borders(1).Color},
-                    "right": {"style": cell.api.Borders(2).LineStyle, "color": cell.api.Borders(2).Color},
-                    "top": {"style": cell.api.Borders(3).LineStyle, "color": cell.api.Borders(3).Color},
+                "vertical_align"  : cell.api.VerticalAlignment,
+                "number_format"   : cell.api.NumberFormat,
+                "border"          : {
+                    "left"  : {"style": cell.api.Borders(1).LineStyle, "color": cell.api.Borders(1).Color},
+                    "right" : {"style": cell.api.Borders(2).LineStyle, "color": cell.api.Borders(2).Color},
+                    "top"   : {"style": cell.api.Borders(3).LineStyle, "color": cell.api.Borders(3).Color},
                     "bottom": {"style": cell.api.Borders(4).LineStyle, "color": cell.api.Borders(4).Color},
                 }
             }
@@ -1445,10 +1861,10 @@ def read_excel_to_json(file_path, sheet_name="Sheet1"):
     app.quit()
 
     final_data = {
-        "cells": data,
-        "merged_cells": merged_cells,
+        "cells"        : data,
+        "merged_cells" : merged_cells,
         "column_widths": column_widths,
-        "row_heights": row_heights
+        "row_heights"  : row_heights
     }
 
     with open("excel_data.json", "w", encoding="utf-8") as f:
@@ -1456,7 +1872,6 @@ def read_excel_to_json(file_path, sheet_name="Sheet1"):
 
     print("✅ Excel 数据已存储为 JSON")
 
-
 def write_json_to_excel(json_file, new_excel="new_test.xlsx", sheet_name="Sheet1"):
     with open(json_file, "r", encoding="utf-8") as f:
         final_data = json.load(f)
@@ -1519,7 +1934,6 @@ def write_json_to_excel(json_file, new_excel="new_test.xlsx", sheet_name="Sheet1
     print(f"✅ 数据已成功写入 {new_excel}")
     time.sleep(2)  # 这里需要一个延时
 
-
 def safe_expand_down(sheet, start_cell='A2'):
     rng = sheet.range(start_cell)
     if not rng.value:
@@ -1530,7 +1944,6 @@ def safe_expand_down(sheet, start_cell='A2'):
         log(f'safe_expand_down failed: {e}')
         return [rng]  # 返回单元格本身
 
-
 # 初始化一个表格
 # data 需要是一个二维列表
 def init_progress_ex(key_id, excel_path, sheet_name='Sheet1'):
@@ -1565,7 +1978,6 @@ def init_progress_ex(key_id, excel_path, sheet_name='Sheet1'):
 
     wb.save()
 
-
 def init_data_ex(key_id, excel_path, header, sheet_name='Sheet1'):
     app, wb, sheet = open_excel(excel_path, sheet_name)
 
@@ -1594,7 +2006,6 @@ def init_data_ex(key_id, excel_path, header, sheet_name='Sheet1'):
 
     wb.save()
 
-
 def format_header_row(sheet, column_count):
     """
     设置标题行样式和列对齐
@@ -1616,7 +2027,6 @@ def format_header_row(sheet, column_count):
         # 自动调整列宽
         sheet.range(f'{col_letter}:{col_letter}').autofit()
 
-
 # 初始化一个表格
 # data 需要是一个二维列表
 def init_progress(excel_path, keyID, sheet_name='Sheet1'):
@@ -1668,7 +2078,6 @@ def init_progress(excel_path, keyID, sheet_name='Sheet1'):
 
     wb.save()
 
-
 def get_progress(excel_path, keyID, sheet_name="Sheet1"):
     app, wb, sheet = open_excel(excel_path, sheet_name)
     # 遍历可用行
@@ -1685,7 +2094,6 @@ def get_progress(excel_path, keyID, sheet_name="Sheet1"):
             else:
                 return False
 
-
 def get_progress_ex(keyID, excel_path, sheet_name="Sheet1"):
     app, wb, sheet = open_excel(excel_path, sheet_name)
     # 遍历可用行
@@ -1703,7 +2111,6 @@ def get_progress_ex(keyID, excel_path, sheet_name="Sheet1"):
                 return False
     close_excel(app, wb)
 
-
 def get_progress_data(excel_path, keyID, sheet_name="Sheet1"):
     app, wb, sheet = open_excel(excel_path, sheet_name)
     # 遍历可用行
@@ -1718,7 +2125,6 @@ def get_progress_data(excel_path, keyID, sheet_name="Sheet1"):
             return result
     return None
 
-
 def get_progress_data_ex(keyID, excel_path, sheet_name="Sheet1"):
     app, wb, sheet = open_excel(excel_path, sheet_name)
     # 遍历可用行
@@ -1733,7 +2139,6 @@ def get_progress_data_ex(keyID, excel_path, sheet_name="Sheet1"):
             return result
     return None
 
-
 def set_progress(excel_path, keyID, status='已完成', sheet_name="Sheet1"):
     app, wb, sheet = open_excel(excel_path, sheet_name)
     # 遍历可用行
@@ -1748,7 +2153,6 @@ def set_progress(excel_path, keyID, status='已完成', sheet_name="Sheet1"):
             wb.save()
             return
 
-
 def set_progress_ex(keyID, excel_path, status='已完成', sheet_name="Sheet1"):
     app, wb, sheet = open_excel(excel_path, sheet_name)
     # 遍历可用行
@@ -1765,7 +2169,6 @@ def set_progress_ex(keyID, excel_path, status='已完成', sheet_name="Sheet1"):
             return
     close_excel(app, wb)
 
-
 def set_data_ex(keyID, data, excel_path, sheet_name="Sheet1"):
     app, wb, sheet = open_excel(excel_path, sheet_name)
     # 遍历可用行
@@ -1780,7 +2183,6 @@ def set_data_ex(keyID, data, excel_path, sheet_name="Sheet1"):
             wb.save()
             return
 
-
 def set_progress_data(excel_path, keyID, data, sheet_name="Sheet1"):
     app, wb, sheet = open_excel(excel_path, sheet_name)
     # 遍历可用行
@@ -1796,7 +2198,6 @@ def set_progress_data(excel_path, keyID, data, sheet_name="Sheet1"):
             wb.save()
             return
 
-
 def set_progress_data_ex(keyID, data, excel_path, sheet_name="Sheet1"):
     app, wb, sheet = open_excel(excel_path, sheet_name)
     # 遍历可用行
@@ -1812,7 +2213,6 @@ def set_progress_data_ex(keyID, data, excel_path, sheet_name="Sheet1"):
             wb.save()
             return
 
-
 def check_progress(excel_path, listKeyID, sheet_name="Sheet1"):
     app, wb, sheet = open_excel(excel_path, sheet_name)
     # 读取整个任务表数据
@@ -1827,7 +2227,6 @@ def check_progress(excel_path, listKeyID, sheet_name="Sheet1"):
     incomplete_tasks = [task_id for task_id in listKeyID if task_status_dict.get(task_id) != "已完成"]
     return len(incomplete_tasks) == 0, incomplete_tasks
 
-
 def check_progress_ex(listKeyID, excel_path, sheet_name="Sheet1"):
     app, wb, sheet = open_excel(excel_path, sheet_name)
     # 读取整个任务表数据
@@ -1842,7 +2241,6 @@ def check_progress_ex(listKeyID, excel_path, sheet_name="Sheet1"):
     incomplete_tasks = [task_id for task_id in listKeyID if task_status_dict.get(task_id) != "已完成"]
     return len(incomplete_tasks) == 0, incomplete_tasks
 
-
 def read_excel_sheet_to_list(file_path, sheet_name=None):
     """
     使用 xlwings 读取 Excel 文件中指定工作表的数据，并返回为二维列表。
@@ -1864,7 +2262,6 @@ def read_excel_sheet_to_list(file_path, sheet_name=None):
     else:
         return [data]
 
-
 def excel_to_dict(excel_path, column_key, column_value, sheet_name=None):
     """
     从 Excel 文件中读取指定两列，生成字典返回（不受中间空行影响）
@@ -1912,7 +2309,6 @@ def excel_to_dict(excel_path, column_key, column_value, sheet_name=None):
             wb.close()
         app.quit()
 
-
 def format_to_text_v2(sheet, columns=None):
     if columns is None or len(columns) == 0:
         return
@@ -1922,6 +2318,140 @@ def format_to_text_v2(sheet, columns=None):
             log(f'设置[{col_name}] 文本格式')
         sheet.range(f'{col_name}:{col_name}').number_format = '@'
 
+def format_to_text_v2_safe(sheet, columns=None, data_rows=None):
+    """
+    更安全的文本格式化函数，避免COM异常
+    
+    Args:
+        sheet: Excel工作表对象
+        columns: 要格式化的列名列表
+        data_rows: 数据行数，用于限制格式化范围
+    """
+    if columns is None or len(columns) == 0:
+        return
+
+    # 确保columns是列表
+    if not isinstance(columns, list):
+        columns = [columns]
+
+    for col_name in columns:
+        try:
+            if isinstance(col_name, int):
+                col_name = xw.utils.col_name(col_name)
+
+            log(f'安全设置[{col_name}] 文本格式')
+
+            # 如果指定了数据行数，只格式化有数据的范围
+            if data_rows and data_rows > 0:
+                # 格式化从第1行到数据行数的范围
+                range_str = f'{col_name}1:{col_name}{data_rows}'
+                sheet.range(range_str).number_format = '@'
+            else:
+                # 检查列是否有数据，如果没有则跳过
+                try:
+                    # 先检查第一个单元格是否存在
+                    test_range = sheet.range(f'{col_name}1')
+                    if test_range.value is not None or sheet.used_range.last_cell.column >= column_name_to_index(col_name) + 1:
+                        sheet.range(f'{col_name}:{col_name}').number_format = '@'
+                    else:
+                        log(f'列 {col_name} 没有数据，跳过格式化')
+                except:
+                    log(f'列 {col_name} 格式化失败，跳过')
+
+        except Exception as e:
+            log(f'设置列 {col_name} 文本格式失败: {e}，继续处理其他列')
+
+def pre_format_columns_safe(sheet, columns, data_rows):
+    """
+    预格式化函数：在写入数据前安全地设置列格式
+    
+    Args:
+        sheet: Excel工作表对象
+        columns: 要格式化的列名列表
+        data_rows: 预期数据行数
+    """
+    if not columns or not isinstance(columns, list):
+        return
+
+    for col_name in columns:
+        try:
+            if isinstance(col_name, int):
+                col_name = xw.utils.col_name(col_name)
+
+            log(f'预格式化列 [{col_name}] 为文本格式')
+
+            # 方法1：先创建最小范围，避免整列操作
+            try:
+                # 创建足够大的范围来覆盖预期数据
+                range_str = f'{col_name}1:{col_name}{max(data_rows, 1000)}'
+                sheet.range(range_str).number_format = '@'
+                log(f'预格式化成功: {range_str}')
+            except Exception as e1:
+                log(f'预格式化方法1失败: {e1}')
+
+                # 方法2：逐行设置格式，更安全但稍慢
+                try:
+                    for row in range(1, data_rows + 1):
+                        cell = sheet.range(f'{col_name}{row}')
+                        cell.number_format = '@'
+                    log(f'逐行预格式化成功: {col_name}')
+                except Exception as e2:
+                    log(f'逐行预格式化也失败: {e2}')
+
+        except Exception as e:
+            log(f'预格式化列 {col_name} 失败: {e}，继续处理其他列')
+
+def post_format_columns_safe(sheet, columns, data_rows):
+    """
+    后格式化函数：在写入数据后确认列格式并强制转换为文本
+    
+    Args:
+        sheet: Excel工作表对象
+        columns: 要格式化的列名列表
+        data_rows: 实际数据行数
+    """
+    if not columns or not isinstance(columns, list):
+        return
+
+    for col_name in columns:
+        try:
+            if isinstance(col_name, int):
+                col_name = xw.utils.col_name(col_name)
+
+            log(f'后格式化列 [{col_name}] 为文本格式')
+
+            # 只对实际有数据的行进行格式化
+            if data_rows > 0:
+                range_str = f'{col_name}1:{col_name}{data_rows}'
+                target_range = sheet.range(range_str)
+                
+                # 设置格式为文本
+                target_range.number_format = '@'
+                
+                # 关键步骤：读取数据并重新写入，触发文本转换
+                # 这样可以将已经写入的数字转换为文本格式
+                values = target_range.value
+                if values is not None:
+                    # 处理单个值的情况
+                    if not isinstance(values, list):
+                        if values != '':
+                            target_range.value = str(values)
+                    # 处理列表的情况（单列多行）
+                    elif len(values) > 0:
+                        # 检查是否是二维数组（实际上单列应该是一维数组）
+                        if isinstance(values[0], list):
+                            # 二维数组，取第一列
+                            converted_values = [[str(row[0]) if row[0] is not None and row[0] != '' else row[0]] for row in values]
+                        else:
+                            # 一维数组
+                            converted_values = [[str(val)] if val is not None and val != '' else [val] for val in values]
+                        # 重新写入（这次会按照文本格式写入）
+                        target_range.value = converted_values
+                
+                log(f'后格式化并转换成功: {range_str}')
+
+        except Exception as e:
+            log(f'后格式化列 {col_name} 失败: {e}，继续处理其他列')
 
 def format_to_text(sheet, columns=None):
     if columns is None:
@@ -1936,7 +2466,6 @@ def format_to_text(sheet, columns=None):
                 log(f'设置[{c}] 文本格式')
                 sheet.range(f'{col_name}:{col_name}').number_format = '@'
 
-
 def format_to_date(sheet, columns=None):
     if columns is None:
         return
@@ -1952,7 +2481,6 @@ def format_to_date(sheet, columns=None):
                 log(f'设置[{c}] 时间格式')
                 sheet.range(f'{col_name}:{col_name}').number_format = 'yyyy-mm-dd'
 
-
 def format_to_datetime(sheet, columns=None):
     if columns is None:
         return
@@ -1968,7 +2496,6 @@ def format_to_datetime(sheet, columns=None):
                 log(f'设置[{c}] 时间格式')
                 sheet.range(f'{col_name}:{col_name}').number_format = 'yyyy-mm-dd hh:mm:ss'
 
-
 def format_to_month(sheet, columns=None):
     if columns is None:
         return
@@ -1982,15 +2509,14 @@ def format_to_month(sheet, columns=None):
                 log(f'设置[{c}] 年月格式')
                 sheet.range(f'{col_name}:{col_name}').number_format = 'yyyy-mm'
 
-
 def add_sum_for_cell(sheet, col_list, row=2):
     last_row = sheet.range('A' + str(sheet.cells.last_cell.row)).end('up').row
-    for col_name in col_list:
-        col_letter = find_column_by_data(sheet, 1, col_name)
-        sheet.range(f'{col_letter}{row}').formula = f'=SUM({col_letter}{row + 1}:{col_letter}{last_row})'
-        sheet.range(f'{col_letter}{row}').api.Font.Color = 255
-        sheet.range(f'{col_letter}:{col_letter}').autofit()
-
+    if last_row > row:
+        for col_name in col_list:
+            col_letter = find_column_by_data(sheet, 1, col_name)
+            sheet.range(f'{col_letter}{row}').formula = f'=SUM({col_letter}{row + 1}:{col_letter}{last_row})'
+            sheet.range(f'{col_letter}{row}').api.Font.Color = 255
+            sheet.range(f'{col_letter}:{col_letter}').autofit()
 
 def clear_for_cell(sheet, col_list, row=2):
     last_row = sheet.range('A' + str(sheet.cells.last_cell.row)).end('up').row
@@ -1998,7 +2524,6 @@ def clear_for_cell(sheet, col_list, row=2):
         col_letter = find_column_by_data(sheet, 1, col_name)
         sheet.range(f'{col_letter}{row}').value = ''
 
-
 def color_for_column(sheet, col_list, color_name, start_row=2):
     last_row = sheet.range('A' + str(sheet.cells.last_cell.row)).end('up').row
     for col_name in col_list:
@@ -2007,7 +2532,6 @@ def color_for_column(sheet, col_list, color_name, start_row=2):
             sheet.range(f'{col_letter}{start_row}:{col_letter}{last_row}').api.Font.ColorIndex = excel_color_index[
                 color_name]
 
-
 def add_formula_for_column(sheet, col_name, formula, start_row=2):
     last_row = sheet.range('A' + str(sheet.cells.last_cell.row)).end('up').row
     col_letter = find_column_by_data(sheet, 1, col_name)
@@ -2020,7 +2544,7 @@ def add_formula_for_column(sheet, col_name, formula, start_row=2):
             # AutoFill 快速填充到所有行（start_row 到 last_row）
             sheet.range(f'{col_letter}{start_row}').api.AutoFill(
                 sheet.range(f'{col_letter}{start_row}:{col_letter}{last_row}').api)
-
+        sheet.range(f'{col_letter}:{col_letter}').autofit()
 
 def autofit_column(sheet, columns=None):
     if columns is None:
@@ -2040,7 +2564,6 @@ def autofit_column(sheet, columns=None):
                 sheet.range(f'{col_name}:{col_name}').api.WrapText = True
                 sheet.range(f'{col_name}:{col_name}').autofit()
 
-
 def specify_column_width(sheet, columns=None, width=150):
     if columns is None:
         return
@@ -2056,7 +2579,6 @@ def specify_column_width(sheet, columns=None, width=150):
                 log(f'设置[{c}]宽度: {width}')
                 sheet.range(f'{col_name}:{col_name}').column_width = width
 
-
 def format_to_money(sheet, columns=None):
     if columns is None:
         return
@@ -2072,7 +2594,6 @@ def format_to_money(sheet, columns=None):
                 log(f'设置[{c}] 金额格式')
                 sheet.range(f'{col_name}:{col_name}').number_format = '¥#,##0.00'
 
-
 def format_to_percent(sheet, columns=None, decimal_places=2):
     if columns is None:
         return
@@ -2092,7 +2613,6 @@ def format_to_percent(sheet, columns=None, decimal_places=2):
                 else:
                     sheet.range(f'{col_name}:{col_name}').number_format = f'0.{"0" * decimal_places}%'
 
-
 def format_to_number(sheet, columns=None, decimal_places=2):
     if not columns or not isinstance(columns, (list, tuple, set)):
         log(f'未提供有效列名列表（{columns}），跳过格式转换')
@@ -2117,7 +2637,6 @@ def format_to_number(sheet, columns=None, decimal_places=2):
                 sheet.range(f'{col_name}:{col_name}').number_format = number_format
                 break  # 如果一列只匹配一个关键词可提前退出
 
-
 # def format_to_number(sheet, columns=None, decimal_places=2):
 #     if columns is None or not isinstance(columns, list):
 #         log('跳过格式化成数字', columns)
@@ -2138,6 +2657,21 @@ def format_to_number(sheet, columns=None, decimal_places=2):
 #                 else:
 #                     sheet.range(f'{col_name}:{col_name}').number_format = f'0.{"0" * decimal_places}'
 
+def hidden_columns(sheet, columns=None):
+    if columns is None:
+        return
+    used_range_col = sheet.range('A1').expand('right')
+    for j, cell in enumerate(used_range_col):
+        col = j + 1
+        col_name = index_to_column_name(col)
+        col_val = sheet.range(f'{col_name}1').value
+        if col_val is None:
+            continue
+        for c in columns:
+            if c in col_val:
+                log(f'设置[{c}] 隐藏')
+                sheet.range(f'{col_name}:{col_name}').column_width = 0
+
 def column_to_right(sheet, columns=None):
     if columns is None:
         return
@@ -2153,11 +2687,10 @@ def column_to_right(sheet, columns=None):
                 # 水平对齐： # -4108：居中 # -4131：左对齐 # -4152：右对齐
                 # 垂直对齐： # -4108：居中 # -4160：顶部对齐 # -4107：底部对齐
                 # 所有列水平居中和垂直居中
-                log(f'设置[{c}] 水平垂直居中')
+                log(f'设置[{c}] 水平右对齐')
                 sheet.range(f'{col_name}:{col_name}').api.HorizontalAlignment = -4152
                 sheet.range(f'{col_name}:{col_name}').api.VerticalAlignment = -4108
 
-
 def column_to_left(sheet, columns=None):
     if columns is None:
         return
@@ -2177,7 +2710,6 @@ def column_to_left(sheet, columns=None):
                 sheet.range(f'{col_name}:{col_name}').api.HorizontalAlignment = -4131
                 sheet.range(f'{col_name}:{col_name}').api.VerticalAlignment = -4108
 
-
 def beautify_title(sheet):
     log('美化标题')
     used_range_col = sheet.range('A1').expand('right')
@@ -2196,6 +2728,15 @@ def beautify_title(sheet):
         sheet.range(f'{col_name}:{col_name}').api.VerticalAlignment = -4108
     sheet.autofit()
 
+def set_body_style(sheet, row_start, row_end=None):
+    if row_end is None:
+        row_end = get_last_used_row(sheet)
+
+    range = sheet.range(f'{row_start}:{row_end}')
+    # 设置字体名称
+    range.font.name = 'Calibri'
+    # 设置字体大小
+    range.font.size = 11
 
 def set_title_style(sheet, rows=2):
     col = get_max_column_letter(sheet)
@@ -2219,7 +2760,6 @@ def set_title_style(sheet, rows=2):
 
     sheet.autofit()
 
-
 def move_sheet_to_position(wb, sheet_name, position):
     # 获取要移动的工作表
     sheet = wb.sheets[sheet_name]
@@ -2233,13 +2773,11 @@ def move_sheet_to_position(wb, sheet_name, position):
     # 保存工作簿
     wb.save()
 
-
 # Excel 文件锁管理器
 import threading
 import time
 from collections import defaultdict
 
-
 class ExcelFileLockManager:
     """Excel 文件锁管理器，用于管理不同 Excel 文件的并发访问"""
 
@@ -2272,7 +2810,7 @@ class ExcelFileLockManager:
         # 记录等待请求
         with self._lock:
             self._waiting_queue[excel_path].append({
-                'priority': priority,
+                'priority' : priority,
                 'timestamp': time.time(),
                 'thread_id': threading.get_ident()
             })
@@ -2345,11 +2883,9 @@ class ExcelFileLockManager:
                 # 比如检查文件最后访问时间等
                 pass
 
-
 # 全局 Excel 文件锁管理器实例
 excel_lock_manager = ExcelFileLockManager()
 
-
 def open_excel_with_lock(excel_path, sheet_name='Sheet1', timeout=30):
     """
     带锁的 Excel 打开函数，支持复用已打开的实例
@@ -2409,7 +2945,6 @@ def open_excel_with_lock(excel_path, sheet_name='Sheet1', timeout=30):
         excel_lock_manager.release_excel_lock(excel_path)
         return None, None, None
 
-
 def close_excel_with_lock(excel_path, app, wb, force_close=False):
     """
     带锁的 Excel 关闭函数
@@ -2435,7 +2970,6 @@ def close_excel_with_lock(excel_path, app, wb, force_close=False):
     finally:
         excel_lock_manager.release_excel_lock(excel_path)
 
-
 def write_data_with_lock(excel_path, sheet_name, data, format_to_text_colunm=None):
     """
     带锁的数据写入函数，复用 Excel 实例
@@ -2466,7 +3000,6 @@ def write_data_with_lock(excel_path, sheet_name, data, format_to_text_colunm=Non
         log(f"写入数据失败: {e}")
         return False
 
-
 def format_excel_with_lock(excel_path, sheet_name, format_func, *args, **kwargs):
     """
     带锁的 Excel 格式化函数
@@ -2493,21 +3026,80 @@ def format_excel_with_lock(excel_path, sheet_name, format_func, *args, **kwargs)
         log(f"格式化失败: {e}")
         return False
 
-
+# 经过观察 fortmat时 传入函数需要为类函数且第二个参数必须是 sheet
 def batch_excel_operations(excel_path, operations):
     """
-    批量 Excel 操作函数，一次性打开 Excel 执行多个操作
-
+    批量 Excel 操作函数，自动分批处理，避免一次操作过多sheet导致Excel COM错误
+    保持操作的原始顺序执行
+    
     Args:
         excel_path: Excel 文件路径
         operations: 操作列表，每个操作是 (sheet_name, operation_type, data, format_func) 的元组
-                   operation_type: 'write' 或 'format'
-                   data: 写入的数据（仅 write 操作需要）
-                   format_func: 格式化函数（仅 format 操作需要）
-
+                   operation_type: 'write', 'format', 'delete', 'move', 'active'
+                   
     Returns:
         bool: 是否全部操作成功
     """
+    if not operations:
+        return True
+
+    # 批处理大小设置：每批最多处理8个操作
+    MAX_OPERATIONS_PER_BATCH = 8
+
+    try:
+        # 计算需要分几批
+        total_batches = (len(operations) + MAX_OPERATIONS_PER_BATCH - 1) // MAX_OPERATIONS_PER_BATCH
+        log(f"分{total_batches}批执行{len(operations)}个操作，每批最多{MAX_OPERATIONS_PER_BATCH}个，保持原始顺序")
+
+        # 按顺序分批执行
+        for batch_idx in range(total_batches):
+            start_idx = batch_idx * MAX_OPERATIONS_PER_BATCH
+            end_idx = min(start_idx + MAX_OPERATIONS_PER_BATCH, len(operations))
+            batch_operations = operations[start_idx:end_idx]
+
+            log(f"执行第{batch_idx + 1}/{total_batches}批操作（{start_idx + 1}-{end_idx}），共{len(batch_operations)}个操作")
+
+            # 重试机制
+            max_retries = 3
+            for retry in range(max_retries):
+                try:
+                    # 强制垃圾回收
+                    import gc
+                    gc.collect()
+
+                    if _execute_operations_batch(excel_path, batch_operations):
+                        log(f"第{batch_idx + 1}批操作成功")
+                        break
+                    else:
+                        log(f"第{batch_idx + 1}批操作失败，重试 {retry + 1}/{max_retries}")
+                        if retry == max_retries - 1:
+                            log(f"第{batch_idx + 1}批操作最终失败")
+                            return False
+                        import time
+                        time.sleep(3)
+                except Exception as e:
+                    log(f"第{batch_idx + 1}批操作异常: {e}")
+                    if retry == max_retries - 1:
+                        return False
+                    import time
+                    time.sleep(3)
+
+            # 批次间延迟
+            if batch_idx < total_batches - 1:
+                import time
+                time.sleep(1)
+
+        log(f"所有批量操作完成: {excel_path}")
+        return True
+
+    except Exception as e:
+        log(f"批量操作过程异常: {e}")
+        return False
+
+def _execute_operations_batch(excel_path, operations):
+    """
+    执行单个批次的操作
+    """
     app, wb, sheet = open_excel_with_lock(excel_path)
     if not app or not wb:
         log(f"无法打开 Excel 文件: {excel_path}")
@@ -2515,46 +3107,101 @@ def batch_excel_operations(excel_path, operations):
 
     try:
         for sheet_name, operation_type, *args in operations:
-            # 获取或创建工作表
+            # 根据操作类型决定是否需要获取或创建工作表
+            sheet = None
+
+            # 删除操作不需要获取sheet对象
+            if operation_type == 'delete':
+                log(f'删除sheet: {sheet_name}')
+                delete_sheet_if_exists(wb, sheet_name)
+                continue
+
+            # 其他操作需要获取或创建工作表
             if isinstance(sheet_name, str):
                 sheet_names = [s.name.strip().lower() for s in wb.sheets]
                 if sheet_name.strip().lower() in sheet_names:
                     sheet = wb.sheets[sheet_name]
                 else:
-                    sheet = wb.sheets.add(sheet_name, after=wb.sheets[-1])
+                    # 只有在需要操作sheet内容时才创建
+                    if operation_type in ['write', 'format']:
+                        sheet = wb.sheets.add(sheet_name, after=wb.sheets[-1])
+                    else:
+                        log(f"警告: 操作 {operation_type} 需要的sheet {sheet_name} 不存在，跳过此操作")
+                        continue
             else:
                 sheet = wb.sheets[sheet_name]
 
-            sheet.activate()
+            if sheet:
+                sheet.activate()
 
             if operation_type == 'write':
-                data, format_to_text_colunm = args[:2]
+                data, format_to_text_colunm = args[0], args[1:] if len(args) > 1 else None
                 # 清空工作表
                 sheet.clear()
-                # 格式化文本列
-                format_to_text_v2(sheet, format_to_text_colunm)
+
+                # 先设置文本格式，再写入数据（确保格式生效）
+                if format_to_text_colunm and format_to_text_colunm[0]:
+                    try:
+                        # 使用安全的预格式化方式
+                        pre_format_columns_safe(sheet, format_to_text_colunm[0], len(data))
+                    except Exception as e:
+                        log(f"预格式化失败: {e}，继续执行")
+
                 # 写入数据
+                log(f"批量操作,写入数据到: {sheet_name}")
                 sheet.range('A1').value = data
-                log(f"批量操作：写入数据到 {sheet_name}")
+
+                # 写入后再次确认格式（双重保险）
+                if format_to_text_colunm and format_to_text_colunm[0]:
+                    try:
+                        post_format_columns_safe(sheet, format_to_text_colunm[0], len(data))
+                    except Exception as e:
+                        log(f"后格式化失败: {e}")
 
             elif operation_type == 'format':
                 format_func, format_args = args[0], args[1:] if len(args) > 1 else ()
                 # 执行格式化
                 format_func(sheet, *format_args)
-                log(f"批量操作：格式化工作表 {sheet_name}")
+
+            elif operation_type == 'move':
+                log(f'移动sheet: {sheet_name}')
+                position = args[0]
+                move_sheet_to_position(wb, sheet_name, position)
+
+            elif operation_type == 'active':
+                log(f'激活sheet: {sheet_name}')
+                sheet.activate()
 
         # 保存所有更改
         wb.save()
-        log(f"批量操作完成: {excel_path}")
         return True
 
     except Exception as e:
-        log(f"批量操作失败: {e}")
+        log(f"单批次操作失败: {e}")
         return False
     finally:
         # 释放锁但不关闭 Excel（保持复用）
         excel_lock_manager.release_excel_lock(excel_path)
+        close_excel_with_lock(excel_path, app, wb, True)
 
+def close_excel_file(file_path):
+    file_path = os.path.abspath(file_path).lower()
+
+    for proc in psutil.process_iter(['pid', 'name']):
+        if proc.info['name'] and proc.info['name'].lower() in ['excel.exe', 'wps.exe']:  # 只找 Excel
+            try:
+                for f in proc.open_files():
+                    if os.path.abspath(f.path).lower() == file_path:
+                        print(f"文件被 Excel 占用 (PID: {proc.pid})，正在关闭进程...")
+                        proc.terminate()
+                        proc.wait(timeout=3)
+                        print("已关闭。")
+                        return True
+            except (psutil.NoSuchProcess, psutil.AccessDenied):
+                continue
+
+    print("文件没有被 Excel 占用。")
+    return False
 
 def force_close_excel_file(excel_path):
     """
@@ -2572,7 +3219,6 @@ def force_close_excel_file(excel_path):
     except Exception as e:
         log(f"强制关闭 Excel 文件失败: {e}")
 
-
 def wait_for_excel_available(excel_path, timeout=60, check_interval=1):
     """
     等待 Excel 文件可用
@@ -2594,7 +3240,6 @@ def wait_for_excel_available(excel_path, timeout=60, check_interval=1):
     log(f"等待 Excel 文件可用超时: {excel_path}")
     return False
 
-
 def smart_excel_operation(excel_path, operation_func, priority=0, timeout=60, max_retries=3):
     """
     智能 Excel 操作函数，支持优先级、重试和更好的错误处理
@@ -2661,7 +3306,6 @@ def smart_excel_operation(excel_path, operation_func, priority=0, timeout=60, ma
 
     return False
 
-
 def batch_excel_operations_with_priority(excel_path, operations, priority=0, timeout=60):
     """
     带优先级的批量 Excel 操作函数
@@ -2715,7 +3359,6 @@ def batch_excel_operations_with_priority(excel_path, operations, priority=0, tim
 
     return smart_excel_operation(excel_path, batch_operation, priority, timeout)
 
-
 def wait_for_excel_available_with_priority(excel_path, timeout=60, check_interval=1, priority=0):
     """
     等待 Excel 文件可用（带优先级）
@@ -2738,7 +3381,6 @@ def wait_for_excel_available_with_priority(excel_path, timeout=60, check_interva
     log(f"等待 Excel 文件可用超时: {excel_path}")
     return False
 
-
 def get_excel_status(excel_path):
     """
     获取 Excel 文件状态信息
@@ -2750,8 +3392,11 @@ def get_excel_status(excel_path):
         dict: 状态信息
     """
     return {
-        'is_open': excel_lock_manager.is_excel_open(excel_path),
-        'waiting_count': excel_lock_manager.get_waiting_count(excel_path),
+        'is_open'        : excel_lock_manager.is_excel_open(excel_path),
+        'waiting_count'  : excel_lock_manager.get_waiting_count(excel_path),
         'operation_count': excel_lock_manager.get_operation_count(excel_path),
-        'has_lock': excel_lock_manager.get_file_lock(excel_path).locked()
+        'has_lock'       : excel_lock_manager.get_file_lock(excel_path).locked()
     }
+
+def get_last_used_row(sheet):
+    return sheet.used_range.last_cell.row