pyxllib 0.3.91__tar.gz → 0.3.93__tar.gz

{pyxllib-0.3.91/pyxllib.egg-info → pyxllib-0.3.93}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pyxllib
-Version: 0.3.91
+Version: 0.3.93
 Summary: 厦门理工模式识别团队通用python代码工具库
 Home-page: https://github.com/XLPRUtils/pyxllib
 Author: code4101

{pyxllib-0.3.91 → pyxllib-0.3.93}/pyxllib/data/echarts.py

@@ -29,7 +29,7 @@ class XlChart(Chart):
     def set_title(self, title):
         self.set_global_opts(title_opts=pyecharts.options.TitleOpts(title=title))
 
-    def add_series(self, name, data, *, type=None, color=None, is_selected=True, labels=None,
+    def add_series(self, name, data, *, type=None, color=None, labels=None,
                    **kwargs):
         """ 垃圾pyecharts，毁我青春~~
 
@@ -54,7 +54,7 @@ class XlChart(Chart):
                 kwargs['label']['formatter'] = fmt
 
         self._append_color(color)
-        self._append_legend(name, is_selected)
+        self._append_legend(name)
 
         self.options.get('series').append(
             {

{pyxllib-0.3.91 → pyxllib-0.3.93}/pyxllib/file/xlsxlib.py

@@ -117,7 +117,7 @@ def is_valid_excel_address(address):
         return is_valid_excel_cell(address)
 
 
-@run_once('str')
+@run_once('str', debug=True)
 def xlfmt2pyfmt_date(xl_fmt):
     """ 日期的渲染操作
 
@@ -213,7 +213,7 @@ def xlfmt2pyfmt_time(xl_fmt):
     return ':'.join(components)
 
 
-@run_once('str')
+# @run_once('str')
 def xlfmt2pyfmt_datetime(xl_fmt):
     """ 主要是针对日期、时间的渲染操作
 
@@ -226,12 +226,6 @@ def xlfmt2pyfmt_datetime(xl_fmt):
     return py_fmt
 
 
-@run_once('str')
-def xlfmt2pyfmt(xl_fmt):
-    """ 主要是针对日期、时间的渲染操作 """
-    return xl_fmt
-
-
 def xl_render_value(x, xl_fmt):
     """ 得到单元格简单渲染后的效果
     py里不可能对excel的所有格式进行全覆盖，只是对场景格式进行处理
@@ -721,40 +715,58 @@ class XlWorksheet(openpyxl.worksheet.worksheet.Worksheet):
                                              right=self.max_column, bottom=self.max_row)
         return raw_used_range
 
-    @run_once('id,str')  # 同一个表，同一行不会重复计算
     def is_empty_row(self, row, start_col, end_col):
-        cur_col = start_col
-        # 特地提前检查下最后一列的那个单元格
-        if self.cell(row, end_col).value is not None:
-            return False
-        while cur_col <= end_col:
-            if self.cell(row, cur_col).value is not None:
+        if not hasattr(self, 'is_empty_row_cache'):
+            self.is_empty_row_cache = {}
+        key = (row, start_col, end_col)
+
+        def is_empty_row_core():
+            cur_col = start_col
+            # 特地提前检查下最后一列的那个单元格
+            if self.cell(row, end_col).value is not None:
                 return False
-            # 步长随着尝试的增加，也逐渐降低采样率
-            n = cur_col - start_col + 1
-            # 在最大值m=16384列情况下，/1000，最多检索3404个单元格，/100，最多检索569次，/50最多检索320次
-            # cur_col += (n // 50) + 1
-            # 再变形，加强前面权重，大大降低后面权重
-            if n <= 100:
-                cur_col += 1
-            else:  # 最多54次
-                cur_col += (n // 10)
-
-        return True
+            while cur_col <= end_col:
+                if self.cell(row, cur_col).value is not None:
+                    return False
+                # 步长随着尝试的增加，也逐渐降低采样率
+                n = cur_col - start_col + 1
+                # 在最大值m=16384列情况下，/1000，最多检索3404个单元格，/100，最多检索569次，/50最多检索320次
+                # cur_col += (n // 50) + 1
+                # 再变形，加强前面权重，大大降低后面权重
+                if n <= 100:
+                    cur_col += 1
+                else:  # 最多54次
+                    cur_col += (n // 10)
+
+            return True
+
+        if key not in self.is_empty_row_cache:
+            self.is_empty_row_cache[key] = is_empty_row_core()
+
+        return self.is_empty_row_cache[key]
 
-    @run_once('id,str')  # 同一个表，同一列不会重复计算
     def is_empty_column(self, col, start_row, end_row):
-        cur_row = start_row
-        # 特地提前检查下最后一行的那个单元格
-        if self.cell(end_row, col).value is not None:
-            return False
-        while cur_row <= end_row:
-            if self.cell(cur_row, col).value is not None:
+        if not hasattr(self, 'is_empty_column_cache'):
+            self.is_empty_column_cache = {}
+        key = (col, start_row, end_row)
+
+        def is_empty_column_core():
+            cur_row = start_row
+            # 特地提前检查下最后一行的那个单元格
+            if self.cell(end_row, col).value is not None:
                 return False
-            n = cur_row - start_row + 1
-            # 在最大值n=1048576行情况下，/1000，最多检索7535个单元格，/100，最多检索987次，/50最多检索530次
-            cur_row += (n // 1000) + 1
-        return True
+            while cur_row <= end_row:
+                if self.cell(cur_row, col).value is not None:
+                    return False
+                n = cur_row - start_row + 1
+                # 在最大值n=1048576行情况下，/1000，最多检索7535个单元格，/100，最多检索987次，/50最多检索530次
+                cur_row += (n // 1000) + 1
+            return True
+
+        if key not in self.is_empty_column_cache:
+            self.is_empty_column_cache[key] = is_empty_column_core()
+
+        return self.is_empty_column_cache[key]
 
     def find_last_non_empty_row(self, start_row, end_row, start_col, end_col, m=30):
         # 1 如果剩余行数不多（小于等于m），直接遍历这些行
@@ -864,7 +876,6 @@ class XlWorksheet(openpyxl.worksheet.worksheet.Worksheet):
         # 如果所有分割点都是空的，则返回-1
         return -1
 
-    @run_once('id,str')  # 同一个表，同一行不会重复计算
     def get_usedrange(self):
         """ 定位有效数据区间。
 
@@ -891,48 +902,48 @@ class XlWorksheet(openpyxl.worksheet.worksheet.Worksheet):
 
         :param reset_bounds: 计算出新区域后，是否重置ws的边界值
         """
-        from pyxllib.prog.newbie import get_global_var
-
-        # 初始化边界值
-        left, right, top, bottom = self.min_column, self.max_column, self.min_row, self.max_row
-
-        # start_time = time.time()
-        # 使用优化后的函数找到最下方的行和最右边的列
-        bottom = self.find_last_non_empty_row(top, bottom, left, right)
-        if bottom == -1:
-            return 'A1'  # 空表返回A1占位
-        right = self.find_last_non_empty_column(left, right, top, bottom)
-        if right == -1:
-            return 'A1'
-
-        # 使用优化后的函数找到最上方的行和最左边的列
-        top = self.find_first_non_empty_row(top, bottom, left, right)
-        if top == -1:
-            return 'A1'
-        left = self.find_first_non_empty_column(left, right, top, bottom)
-        if left == -1:
-            return 'A1'
-        # get_global_var('get_usedrange_time')[-1] += time.time() - start_time
-
-        # 2 然后还要再扩范围（根据合并单元格情况）
-        # start_time = time.time()
-        top0, bottom0, left0, right0 = top, bottom, left, right
-        for merged_range in self.merged_cells.ranges:
-            l, t, r, b = merged_range.bounds
-            if top0 <= b <= bottom0 or top0 <= t <= bottom0:
-                if left0 <= r and l < left:
-                    left = l
-                if l <= right0 and r > right:
-                    right = r
-            if left0 <= r <= right0 or left0 <= l <= right0:
-                if top0 <= b and t < top:
-                    top = t
-                if t <= bottom0 and b > bottom:
-                    bottom = b
-        # get_global_var('expandrange_time')[-1] += time.time() - start_time
-
-        used_range = build_range_address(left=left, top=top, right=right, bottom=bottom)
-        return used_range
+        if not hasattr(self, 'usedrange_cache'):
+            # 初始化边界值
+            left, right, top, bottom = self.min_column, self.max_column, self.min_row, self.max_row
+
+            # start_time = time.time()
+            # 使用优化后的函数找到最下方的行和最右边的列
+            bottom = self.find_last_non_empty_row(top, bottom, left, right)
+            if bottom == -1:
+                return 'A1'  # 空表返回A1占位
+            right = self.find_last_non_empty_column(left, right, top, bottom)
+            if right == -1:
+                return 'A1'
+
+            # 使用优化后的函数找到最上方的行和最左边的列
+            top = self.find_first_non_empty_row(top, bottom, left, right)
+            if top == -1:
+                return 'A1'
+            left = self.find_first_non_empty_column(left, right, top, bottom)
+            if left == -1:
+                return 'A1'
+            # get_global_var('get_usedrange_time')[-1] += time.time() - start_time
+
+            # 2 然后还要再扩范围（根据合并单元格情况）
+            # start_time = time.time()
+            top0, bottom0, left0, right0 = top, bottom, left, right
+            for merged_range in self.merged_cells.ranges:
+                l, t, r, b = merged_range.bounds
+                if top0 <= b <= bottom0 or top0 <= t <= bottom0:
+                    if left0 <= r and l < left:
+                        left = l
+                    if l <= right0 and r > right:
+                        right = r
+                if left0 <= r <= right0 or left0 <= l <= right0:
+                    if top0 <= b and t < top:
+                        top = t
+                    if t <= bottom0 and b > bottom:
+                        bottom = b
+            # get_global_var('expandrange_time')[-1] += time.time() - start_time
+
+            self.used_range = build_range_address(left=left, top=top, right=right, bottom=bottom)
+
+        return self.used_range
 
     def copy_worksheet(self, dst_ws):
         """跨工作薄时复制表格内容的功能
@@ -967,7 +978,6 @@ class XlWorksheet(openpyxl.worksheet.worksheet.Worksheet):
             else:
                 yield tuple(cells)
 
-    @run_once('id,str')
     def search(self, pattern, min_row=None, max_row=None, min_col=None, max_col=None, order=None, direction=0):
         """ 查找满足pattern正则表达式的单元格
 
@@ -987,40 +997,55 @@ class XlWorksheet(openpyxl.worksheet.worksheet.Worksheet):
         >> ws.search('年段')
         <Cell '预算总表'.B2>
         """
-        # 1 定界
-        x1, x2 = max(min_row or 1, 1), min(max_row or self.max_row, self.max_row)
-        y1, y2 = max(min_col or 1, 1), min(max_col or self.max_column, self.max_column)
-
-        # 2 遍历
-        if isinstance(pattern, datetime.date):
-            pattern = f'^{(pattern - datetime.date(1899, 12, 30)).days}$'
-
-        if isinstance(pattern, (list, tuple)):
-            cel = None
-            for p in pattern:
-                cel = self.search(p, x1, x2, y1, y2, order)
-                if cel:
-                    # up, down, left, right 找到的单元格四边界
-                    l, u, r, d = getattr(cel.in_range(), 'bounds', (cel.column, cel.row, cel.column, cel.row))
-                    if direction == 0:
-                        x1, x2, y1, y2 = max(x1, d + 1), x2, max(y1, l), min(y2, r)
-                    elif direction == 1:
-                        x1, x2, y1, y2 = max(x1, u), min(x2, d), max(y1, r + 1), y2
-                    elif direction == 2:
-                        x1, x2, y1, y2 = x1, min(x2, u - 1), max(y1, l), min(y2, r)
-                    elif direction == 3:
-                        x1, x2, y1, y2 = max(x1, u), min(x2, d), y1, min(y2, l - 1)
+        if not hasattr(self, 'search_cache'):
+            self.search_cache = {}
+
+        if isinstance(pattern, list):
+            pattern = tuple(pattern)
+
+        key = (pattern, min_row, max_row, min_col, max_col, order, direction)
+
+        def get_search_core():
+            nonlocal pattern
+            # 1 定界
+            x1, x2 = max(min_row or 1, 1), min(max_row or self.max_row, self.max_row)
+            y1, y2 = max(min_col or 1, 1), min(max_col or self.max_column, self.max_column)
+
+            # 2 遍历
+            if isinstance(pattern, datetime.date):
+                pattern = f'^{(pattern - datetime.date(1899, 12, 30)).days}$'
+
+            if isinstance(pattern, tuple):
+                cel = None
+                for p in pattern:
+                    cel = self.search(p, x1, x2, y1, y2, order)
+                    if cel:
+                        # up, down, left, right 找到的单元格四边界
+                        l, u, r, d = getattr(cel.in_range(), 'bounds', (cel.column, cel.row, cel.column, cel.row))
+                        if direction == 0:
+                            x1, x2, y1, y2 = max(x1, d + 1), x2, max(y1, l), min(y2, r)
+                        elif direction == 1:
+                            x1, x2, y1, y2 = max(x1, u), min(x2, d), max(y1, r + 1), y2
+                        elif direction == 2:
+                            x1, x2, y1, y2 = x1, min(x2, u - 1), max(y1, l), min(y2, r)
+                        elif direction == 3:
+                            x1, x2, y1, y2 = max(x1, u), min(x2, d), y1, min(y2, l - 1)
+                        else:
+                            raise ValueError(f'direction参数值错误{direction}')
                     else:
-                        raise ValueError(f'direction参数值错误{direction}')
-                else:
-                    return None
-            return cel
-        else:
-            if isinstance(pattern, str): pattern = re.compile(pattern)
-            for x, y in product(range(x1, x2 + 1), range(y1, y2 + 1), order=order):
-                cell = self.cell(x, y)
-                if cell.celltype() == 1: continue  # 过滤掉合并单元格位置
-                if pattern.search(str(cell.value)): return cell  # 返回满足条件的第一个值
+                        return None
+                return cel
+            else:
+                if isinstance(pattern, str): pattern = re.compile(pattern)
+                for x, y in product(range(x1, x2 + 1), range(y1, y2 + 1), order=order):
+                    cell = self.cell(x, y)
+                    if cell.celltype() == 1: continue  # 过滤掉合并单元格位置
+                    if pattern.search(str(cell.value)): return cell  # 返回满足条件的第一个值
+
+        if key not in self.search_cache:
+            self.search_cache[key] = get_search_core()
+
+        return self.search_cache[key]
 
     findcel = search
 
@@ -1571,12 +1596,12 @@ class XlWorksheet(openpyxl.worksheet.worksheet.Worksheet):
                     current_alignment_dict.pop('wrapText', None)
                     cell.alignment = Alignment(wrapText=True, **current_alignment_dict)
 
-    @run_once('id,str')
     def get_sorted_merged_cells(self):
         """ 将合并单元格按照行列顺序排列。
         """
-        rngs = list(sorted(self.merged_cells.ranges, key=lambda x: (x.min_row, x.min_col)))
-        return rngs
+        if not hasattr(self, 'sorted_merged_cells'):
+            self.sorted_merged_cells = list(sorted(self.merged_cells.ranges, key=lambda x: (x.min_row, x.min_col)))
+        return self.sorted_merged_cells
 
 
 inject_members(XlWorksheet, openpyxl.worksheet.worksheet.Worksheet, white_list=['_cells_by_row'])
@@ -2359,7 +2384,6 @@ def extract_workbook_summary2(file_path, *,
 
     # 1 读取文件wb
     def read_file_by_type():
-        nonlocal load_time
         nonlocal load_time
         suffix = file_path.suffix.lower()
         start_time = time.time()
@@ -2382,7 +2406,10 @@ def extract_workbook_summary2(file_path, *,
     res['fileName'] = file_path.name
     wb = read_file_by_type()
     if wb is None:  # 不支持的文件类型，不报错，只是返回最基本的文件名信息
-        return res
+        if return_mode == 1:
+            return res, load_time
+        else:
+            return res
 
     # 2 提取摘要
     summary2 = wb.extract_summary2()
@@ -2390,7 +2417,8 @@ def extract_workbook_summary2(file_path, *,
     if mode == 1:
         ws = wb.active
         res['ActiveSheet'] = ws.title
-        res['Selection'] = ws.selected_cell
+        if hasattr(ws, 'selected_cell'):
+            res['Selection'] = ws.selected_cell
 
     # res = convert_to_json_compatible(res)
 
@@ -2447,6 +2475,12 @@ def extract_workbook_summary2plus(file_path, **kwargs):
 class WorkbookSummary3:
     """ 计算summary3及衍生版本需要的一些功能组件 """
 
+    @classmethod
+    def count_length(cls, text):
+        if not isinstance(text, str):
+            text = json.dumps(text, ensure_ascii=False, default=str)
+        return len(text)
+
     @classmethod
     def reduce1_delete_empty_cell(cls, summary3):
         """ 删除空单元格 """
@@ -2476,7 +2510,7 @@ class WorkbookSummary3:
 
         # 如果未提供当前摘要长度，则计算之
         if cur_summary_len is None:
-            cur_summary_len = len(json.dumps(summary3, ensure_ascii=False))
+            cur_summary_len = cls.count_length(summary3)
 
         # 1. 计算基准单元格长度
         total_cells_num = sum(len(st['cells']) + 5 for st in summary3['sheets'])
@@ -2507,7 +2541,7 @@ class WorkbookSummary3:
     @classmethod
     def reduce3_fold_rows(cls, summary3, summary_limit_len, *, cur_summary_len=None):
         if cur_summary_len is None:
-            cur_summary_len = len(json.dumps(summary3, ensure_ascii=False))
+            cur_summary_len = cls.count_length(summary3)
 
         # 每个sheet本身其他摘要，按照5个单元格估算
         total_cells_num = sum([(len(st['cells']) + 5) for st in summary3['sheets']])
@@ -2583,7 +2617,7 @@ class WorkbookSummary3:
     @classmethod
     def reduce4_truncate_cells(cls, y, summary_limit_len, *, cur_summary_len=None):
         if cur_summary_len is None:
-            cur_summary_len = len(json.dumps(y, ensure_ascii=False))
+            cur_summary_len = cls.count_length(y)
 
         # 1 预计要删除单元格数
         sheet_cells_num = [len(st['cells']) for st in y['sheets']]
@@ -2597,14 +2631,14 @@ class WorkbookSummary3:
         if total_cells_num < target_reduce_cells_num:
             for st in y['sheets']:
                 st['cells'] = {}
-            return len(json.dumps(y, ensure_ascii=False))
+            return cls.count_length(y)
 
         # 3 否则每张表按照比例删单元格，只保留前面部分的单元格
         left_rate = 1 - target_reduce_cells_num / total_cells_num
         while True:
             for i, st in enumerate(y['sheets']):
                 st['cells'] = dict(islice(st['cells'].items(), int(left_rate * sheet_cells_num[i])))
-            cur_summary_len = len(json.dumps(y, ensure_ascii=False))
+            cur_summary_len = cls.count_length(y)
             if cur_summary_len <= summary_limit_len:
                 return cur_summary_len
             if left_rate * total_cells_num < 1:
@@ -2618,7 +2652,7 @@ class WorkbookSummary3:
     def reduce5_truncate_sheets(cls, y, summary_limit_len, *, cur_summary_len=None):
         """ 计算平均每张表的长度，保留前面部分的表格 """
         if cur_summary_len is None:
-            cur_summary_len = len(json.dumps(y, ensure_ascii=False))
+            cur_summary_len = cls.count_length(y)
 
         n = len(y['sheets'])
         avg_sheet_len = cur_summary_len / n
@@ -2626,7 +2660,7 @@ class WorkbookSummary3:
         y['sheets'] = y['sheets'][:n - target_reduce_sheet_num]
 
         while y['sheets']:
-            cur_summary_len = len(json.dumps(y, ensure_ascii=False))
+            cur_summary_len = cls.count_length(y)
             if cur_summary_len <= summary_limit_len:
                 return cur_summary_len
             y['sheets'] = y['sheets'][:-1]  # 依次尝试删除最后一张表格的详细信息
@@ -2645,13 +2679,13 @@ class WorkbookSummary3:
             ]
 
             # 0 摘要本来就不大
-            cur_summary_len = len(json.dumps(y, ensure_ascii=False))
+            cur_summary_len = cls.count_length(y)
             if cur_summary_len <= summary_limit_len:
                 return y
 
             # 1 删除空单元格
             cls.reduce1_delete_empty_cell(y)
-            cur_summary_len = len(json.dumps(y, ensure_ascii=False))
+            cur_summary_len = cls.count_length(y)
             if cur_summary_len <= summary_limit_len:
                 y['mode'] = ', '.join(mode_tags[:1])
                 return y
@@ -2664,7 +2698,7 @@ class WorkbookSummary3:
 
             # 3 同构数据，省略显示（有大量相同行数据，折叠省略表达）
             cls.reduce3_fold_rows(y, summary_limit_len, cur_summary_len=cur_summary_len)
-            cur_summary_len = len(json.dumps(y, ensure_ascii=False))
+            cur_summary_len = cls.count_length(y)
             if cur_summary_len <= summary_limit_len:
                 y['mode'] = ', '.join(mode_tags[:3])
                 return y
@@ -2708,7 +2742,7 @@ class WorkbookSummary3:
         :param active_sheet_weight: 当前活动表格被删除的权重，0.5表示按比例被删除的量只有其他表格的一半
         """
         if cur_summary_len is None:
-            cur_summary_len = len(json.dumps(y, ensure_ascii=False))
+            cur_summary_len = cls.count_length(y)
 
         active_sheet = y['ActiveSheet']
 
@@ -2738,7 +2772,7 @@ class WorkbookSummary3:
         if total_cells_num < target_reduce_cells_num:
             for st in y['sheets']:
                 st['cells'] = {}
-            return len(json.dumps(y, ensure_ascii=False))
+            return cls.count_length(y)
 
         # 4 否则每张表按照比例删单元格，只保留前面部分的单元格
         left_rate = 1 - r  # 原始保留比例
@@ -2750,7 +2784,7 @@ class WorkbookSummary3:
                 else:
                     # 其他sheet按照w2权重删除单元格
                     st['cells'] = dict(islice(st['cells'].items(), int(left_rate * w2 * sheet_cells_num[i])))
-            cur_summary_len = len(json.dumps(y, ensure_ascii=False))
+            cur_summary_len = cls.count_length(y)
             if cur_summary_len <= summary_limit_len:
                 return cur_summary_len
             if left_rate * total_cells_num < 1:
@@ -2764,7 +2798,7 @@ class WorkbookSummary3:
     def reduce5b(cls, y, summary_limit_len, *, cur_summary_len=None):
         """ 计算平均每张表的长度，保留前面部分的表格 """
         if cur_summary_len is None:
-            cur_summary_len = len(json.dumps(y, ensure_ascii=False))
+            cur_summary_len = cls.count_length(y)
 
         n = len(y['sheets'])
         active_sheet_name = y['ActiveSheet']
@@ -2774,7 +2808,7 @@ class WorkbookSummary3:
         # y['sheets'] = y['sheets'][:n - target_reduce_sheet_num]
 
         while y['sheets']:
-            cur_summary_len = len(json.dumps(y, ensure_ascii=False))
+            cur_summary_len = cls.count_length(y)
             if cur_summary_len <= summary_limit_len:
                 return cur_summary_len
 
@@ -2803,13 +2837,13 @@ class WorkbookSummary3:
             ]
 
             # 0 摘要本来就不大
-            cur_summary_len = len(json.dumps(y, ensure_ascii=False))
+            cur_summary_len = cls.count_length(y)
             if cur_summary_len <= summary_limit_len:
                 return y
 
             # 1 删除空单元格
             cls.reduce1_delete_empty_cell(y)
-            cur_summary_len = len(json.dumps(y, ensure_ascii=False))
+            cur_summary_len = cls.count_length(y)
             if cur_summary_len <= summary_limit_len:
                 y['mode'] = ', '.join(mode_tags[:1])
                 return y
@@ -2822,7 +2856,7 @@ class WorkbookSummary3:
 
             # 3 同构数据，省略显示（有大量相同行数据，折叠省略表达）
             cls.reduce3_fold_rows(y, summary_limit_len, cur_summary_len=cur_summary_len)
-            cur_summary_len = len(json.dumps(y, ensure_ascii=False))
+            cur_summary_len = cls.count_length(y)
             if cur_summary_len <= summary_limit_len:
                 y['mode'] = ', '.join(mode_tags[:3])
                 return y
@@ -2845,8 +2879,10 @@ class WorkbookSummary3:
             'sheets': x['sheets'],
             'mode': 'Complete information',
             'ActiveSheet': x['ActiveSheet'],  # 当期激活的工作表
-            'Selection': x['Selection'],
         }
+        if 'Selection' in x:
+            # 最多截取250个字符。（一般情况下这个很小的，只是在很极端情况，比如离散选中了非常多区域，这个可能就会太长
+            y['Selection'] = x['Selection'][:250]
 
         # 处理前确保下cells字段存在，避免后续很多处理过程要特判
         for st in y['sheets']:
@@ -2863,6 +2899,17 @@ class WorkbookSummary3:
         return y
 
 
+class WorkbookSummary3plus(WorkbookSummary3):
+    """ 标准的token计算方式，不过暂不打算实装使用 """
+
+    @classmethod
+    def count_length(cls, text):
+        from pyxlpr.data.gptlib import Tokenizer
+        if not isinstance(text, str):
+            text = json.dumps(text, ensure_ascii=False, default=str)
+        return Tokenizer.count_tokens(text)
+
+
 def extract_workbook_summary3(file_path, summary_limit_len=4000, **kwargs):
     """ 增加了全局ratio的计算 """
     data = extract_workbook_summary2(file_path, **kwargs)
@@ -2874,28 +2921,25 @@ def extract_workbook_summary3(file_path, summary_limit_len=4000, **kwargs):
 
 def extract_workbook_summary3b(file_path,
                                summary_limit_len=4000,
-                               timeout_seconds=60,
+                               timeout_seconds=10,
                                return_mode=0,
+                               debug=False,
+                               len_mode=0,
                                **kwargs):
     """
 
     :param summary_limit_len: 摘要长度限制
     :param timeout_seconds: 超时限制
     :param return_mode: 返回模式，0表示只返回摘要，1表示返回摘要和耗时
+    :param len_mode:
+        0, 使用len作为token长度评估
+        1, 使用模型评估实际token长度
     :param kwargs: 其他是summary2读取文件的时候的参数，其实都不太关键，一般不用特地设置
     """
     res = {}
-    res['fileName'] = file_path.name
+    res['fileName'] = Path(file_path).name
     load_time = summary2_time = summary3_time = -1
 
-    # with Timeout(timeout_seconds):
-    #     start_time = time.time()
-    #     res, load_time = extract_workbook_summary2(file_path, mode=1, return_mode=1, **kwargs)
-    #     summary2_time = time.time() - start_time - load_time
-    #     start_time = time.time()
-    #     res = WorkbookSummary3.summary2_to_summary3b(res, summary_limit_len)
-    #     summary3_time = time.time() - start_time
-
     try:
         with Timeout(timeout_seconds):
             start_time = time.time()
@@ -2903,12 +2947,18 @@ def extract_workbook_summary3b(file_path,
             # res = convert_to_json_compatible(res)
             summary2_time = time.time() - start_time - load_time
             start_time = time.time()
-            res = WorkbookSummary3.summary2_to_summary3b(res, summary_limit_len)
+            if len_mode == 1:
+                res = WorkbookSummary3plus.summary2_to_summary3b(res, summary_limit_len)
+            else:
+                res = WorkbookSummary3.summary2_to_summary3b(res, summary_limit_len)
             summary3_time = time.time() - start_time
-    except TimeoutError:
+    except TimeoutError as e:
+        if debug:
+            raise e
         res['error'] = f'超时，未完成摘要提取：{timeout_seconds}秒'
     except Exception as e:
-        # raise e
+        if debug:
+            raise e
         res['error'] = f'提取摘要时发生错误：{format_exception(e, 2)}'
 
     if return_mode == 1: