pyxllib 0.3.90__tar.gz → 0.3.92__tar.gz

{pyxllib-0.3.90/pyxllib.egg-info → pyxllib-0.3.92}/PKG-INFO

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

{pyxllib-0.3.90 → pyxllib-0.3.92}/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.90 → pyxllib-0.3.92}/pyxllib/file/xlsxlib.py

@@ -42,7 +42,9 @@ try:
 except ModuleNotFoundError:
     pass
 
-from pyxllib.prog.pupil import inject_members, dprint, xlmd5, shuffle_dict_keys, Timeout, safe_div
+from pyxllib.prog.newbie import human_readable_number
+from pyxllib.prog.pupil import (inject_members, dprint, xlmd5, shuffle_dict_keys, Timeout,
+                                safe_div, format_exception, DictTool)
 from pyxllib.prog.specialist import browser, TicToc
 from pyxllib.algo.specialist import product
 from pyxllib.text.pupil import calc_chinese_ratio
@@ -249,8 +251,10 @@ def xl_render_value(x, xl_fmt):
         y = x.strftime(xlfmt2pyfmt_time(xl_fmt))
     elif isinstance(x, datetime.timedelta):
         y = str(x)
-    else:
+    elif isinstance(x, (str, int, float, bool)):  # 其他可以json化的数据类型
         y = x
+    else:  # ArrayFormula、DataTableFormula等无法json化的数据，提前转str
+        y = str(x)
     return y
 
 
@@ -717,40 +721,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），直接遍历这些行
@@ -860,7 +882,6 @@ class XlWorksheet(openpyxl.worksheet.worksheet.Worksheet):
         # 如果所有分割点都是空的，则返回-1
         return -1
 
-    @run_once('id,str')  # 同一个表，同一行不会重复计算
     def get_usedrange(self):
         """ 定位有效数据区间。
 
@@ -887,48 +908,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):
         """跨工作薄时复制表格内容的功能
@@ -963,7 +984,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正则表达式的单元格
 
@@ -983,40 +1003,50 @@ 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 = {}
+        key = (pattern, min_row, max_row, min_col, max_col, order, direction)
+
+        def get_search_core():
+            # 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)
+                        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
 
@@ -1567,12 +1597,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'])
@@ -2107,8 +2137,12 @@ def extract_cells_content(ws, usedrange=None):
         if val is None:
             return ''
         else:
-            # return cell.get_render_value()  # 如果感觉这步很慢，可以换一种更简洁的形式
-            return val
+            return cell.get_render_value()
+            # 如果感觉这步很慢，可以换一种更简洁的形式；但是发现下面这种对时间的格式显示还是太不智能。
+            # if not isinstance(val, (str, int, float, bool)):
+            #     return val
+            # else:
+            #     return str(val)
 
     for i in range(usedrange_bound['top'], usedrange_bound['bottom'] + 1):
         for j in range(usedrange_bound['left'], usedrange_bound['right'] + 1):
@@ -2334,25 +2368,27 @@ def extract_workbook_summary(file_path, mode=0,
 
 
 def extract_workbook_summary2(file_path, *,
-                              timeout_seconds=None,
-                              ignore_errors=False,
                               keep_links=False,
                               keep_vba=False,
-                              mode=0):
+                              mode=0,
+                              return_mode=0,
+                              **kwargs):
     """
     :param keep_links: 是否保留外部表格链接数据。如果保留，打开好像会有点问题。
     :param mode:
         0，最原始的summary3摘要
         1，添加当前工作表、单元格位置的信息
+    :param kwargs: 捕捉其他参数，主要是向下兼容，其实现在并没有用
 
     注意这里没有提供read_only可选参数，是因为read_only=True模式在我这里是运行不了的。
     """
-    # 1 读取文件wb
-    file_path = Path(file_path)
-    suffix = file_path.suffix.lower()
 
-    def read_file_by_type(file_path, suffix, keep_links=False):
-        # with TicToc('读取文件'):
+    # 1 读取文件wb
+    def read_file_by_type():
+        nonlocal load_time
+        nonlocal load_time
+        suffix = file_path.suffix.lower()
+        start_time = time.time()
         if suffix in ('.xlsx', '.xlsm'):
             wb = openpyxl.load_workbook(file_path,
                                         keep_links=keep_links,
@@ -2362,38 +2398,33 @@ def extract_workbook_summary2(file_path, *,
         elif suffix == '.csv':
             wb = convert_csv_to_xlsx(file_path)
         else:
-            raise ValueError('不支持的文件类型')
-        return wb
-
-    def process_file(file_path, suffix, timeout_seconds=None, keep_links=False, ignore_errors=False):
-        try:
-            if timeout_seconds is None:
-                wb = read_file_by_type(file_path, suffix, keep_links)
-            else:
-                with Timeout(timeout_seconds):  # 使用之前定义的timeout上下文管理器
-                    wb = read_file_by_type(file_path, suffix, keep_links)
-        except Exception as e:
-            if ignore_errors:
-                return {}
-            else:
-                raise e
+            return None
+        load_time = time.time() - start_time
         return wb
 
-    wb = process_file(file_path, suffix, timeout_seconds, keep_links, ignore_errors)
+    load_time = -1
+    file_path = Path(file_path)
+    res = {}
+    res['fileName'] = file_path.name
+    wb = read_file_by_type()
+    if wb is None:  # 不支持的文件类型，不报错，只是返回最基本的文件名信息
+        return res
 
     # 2 提取摘要
-    # with TicToc('提取摘要'):
-    res = wb.extract_summary2()
-    res['fileName'] = Path(file_path).name
-
-    if mode == 0:
-        pass
-    elif mode == 1:
-        res['ActiveSheet'] = wb.active.title
-        # todo py好像没办法提取Selection。但jsa、vba应该要尽力取出这些相关的特征，尤其在操作等场景很有用
-        # res['SelectionAddress'] = ...
-
-    return res
+    summary2 = wb.extract_summary2()
+    DictTool.ior(res, summary2)
+    if mode == 1:
+        ws = wb.active
+        res['ActiveSheet'] = ws.title
+        if hasattr(ws, 'selected_cell'):
+            res['Selection'] = ws.selected_cell
+
+    # res = convert_to_json_compatible(res)
+
+    if return_mode == 1:
+        return res, load_time
+    else:
+        return res
 
 
 def update_raw_summary2(data):
@@ -2838,10 +2869,11 @@ class WorkbookSummary3:
         y = {
             'fileName': x['fileName'],
             'sheetNames': x['sheetNames'],
-            'ActiveSheet': x['ActiveSheet'],  # 当期激活的工作表
-            # 'SelectionAddress': '',
             'sheets': x['sheets'],
             'mode': 'Complete information',
+            'ActiveSheet': x['ActiveSheet'],  # 当期激活的工作表
+            # 最多截取250个字符。（一般情况下这个很小的，只是在很极端情况，比如离散选中了非常多区域，这个可能就会太长
+            'Selection': x['Selection'][:250],
         }
 
         # 处理前确保下cells字段存在，避免后续很多处理过程要特判
@@ -2868,10 +2900,43 @@ def extract_workbook_summary3(file_path, summary_limit_len=4000, **kwargs):
     return data
 
 
-def extract_workbook_summary3b(file_path, summary_limit_len=4000, **kwargs):
-    """ 增加了全局ratio的计算 """
-    data = extract_workbook_summary2(file_path, mode=1, **kwargs)
-    if not data:
-        return data
-    data = WorkbookSummary3.summary2_to_summary3b(data, summary_limit_len)
-    return data
+def extract_workbook_summary3b(file_path,
+                               summary_limit_len=4000,
+                               timeout_seconds=60,
+                               return_mode=0,
+                               debug=False,
+                               **kwargs):
+    """
+
+    :param summary_limit_len: 摘要长度限制
+    :param timeout_seconds: 超时限制
+    :param return_mode: 返回模式，0表示只返回摘要，1表示返回摘要和耗时
+    :param kwargs: 其他是summary2读取文件的时候的参数，其实都不太关键，一般不用特地设置
+    """
+    res = {}
+    res['fileName'] = Path(file_path).name
+    load_time = summary2_time = summary3_time = -1
+
+    try:
+        with Timeout(timeout_seconds):
+            start_time = time.time()
+            res, load_time = extract_workbook_summary2(file_path, mode=1, return_mode=1, **kwargs)
+            # 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)
+            summary3_time = time.time() - start_time
+    except TimeoutError as e:
+        if debug:
+            raise e
+        res['error'] = f'超时，未完成摘要提取：{timeout_seconds}秒'
+    except Exception as e:
+        if debug:
+            raise e
+        res['error'] = f'提取摘要时发生错误：{format_exception(e, 2)}'
+
+    if return_mode == 1:
+        return res, {'load_time': human_readable_number(load_time),
+                     'summary2_time': human_readable_number(summary2_time),
+                     'summary3_time': human_readable_number(summary3_time)}
+    return res

{pyxllib-0.3.90 → pyxllib-0.3.92}/pyxllib/prog/newbie.py

@@ -420,3 +420,25 @@ def get_global_var(name, default_value=None):
     if name not in g:
         g[name] = default_value
     return g[name]
+
+
+def convert_to_json_compatible(d, custom_converter=None):
+    """ 递归地将字典等类型转换为JSON兼容格式。对于非标准JSON类型，使用自定义转换器或默认转换为字符串。
+
+    :param d: 要转换的字典或列表。
+    :param custom_converter: 自定义转换函数，用于处理非标准JSON类型的值。
+    :return: 转换后的字典或列表。
+
+    todo 这个函数想法是好的，但总感觉精确性中，总容易有些问题的，需要更多的考察测试
+    """
+    if custom_converter is None:
+        custom_converter = str
+
+    if isinstance(d, dict):  # defaultdict呢？
+        return {k: convert_to_json_compatible(v, custom_converter) for k, v in d.items()}
+    elif isinstance(d, list):
+        return [convert_to_json_compatible(v, custom_converter) for v in d]
+    elif isinstance(d, (int, float, str, bool)) or d is None:
+        return d
+    else:
+        return custom_converter(d)

{pyxllib-0.3.90 → pyxllib-0.3.92}/pyxllib/prog/pupil.py

@@ -508,7 +508,7 @@ class Timeout:
     """ 对函数等待执行的功能，限制运行时间
 
     【实现思路】
-    1、最简单的方式是用signal.SIGALRM实现
+    1、最简单的方式是用signal.SIGALRM实现（包括三方库timeout-decorator也有这个局限）
         https://stackoverflow.com/questions/2281850/timeout-function-if-it-takes-too-long-to-finish
         但是这个不支持windows系统~~
     2、那windows和linux通用的做法，就是把原执行函数变成一个子线程来运行
@@ -519,6 +519,7 @@ class Timeout:
         是用一个Timer计时器子线程计时，当timeout超时，使用信号机制给主线程抛出一个异常
             ① 注意，不能子线程直接抛出异常，这样影响不了主线程
             ② 也不能直接抛出错误signal，这样会强制直接中断程序。应该抛出TimeoutError，让后续程序进行超时逻辑的处理
+            ③ 这里是让子线程抛出信号，主线程收到信号后，再抛出TimeoutError
 
     注意：这个函数似乎不支持多线程
     """
@@ -560,10 +561,12 @@ class Timeout:
         def send_signal():
             signal.raise_signal(signal.SIGABRT)
 
+        # 挂起一个警告器，如果"没人"管它，self.seconds就会抛出错误
         self.alarm = threading.Timer(self.seconds, send_signal)
         self.alarm.start()
 
     def __exit__(self, exc_type, exc_val, exc_tb):
+        # with已经运行完了，马上关闭警告器
         self.alarm.cancel()
 
 

{pyxllib-0.3.90 → pyxllib-0.3.92/pyxllib.egg-info}/PKG-INFO

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

{pyxllib-0.3.90 → pyxllib-0.3.92}/setup.py

@@ -30,7 +30,7 @@ _dir = Path(__file__).parent
 
 setup(
     name='pyxllib',  # pip 安装时用的名字
-    version='0.3.90',  # 当前版本，每次更新上传到pypi都需要修改; 第4位版本号一般是修紧急bug
+    version='0.3.92',  # 当前版本，每次更新上传到pypi都需要修改; 第4位版本号一般是修紧急bug
     author='code4101',
     author_email='877362867@qq.com',
     url='https://github.com/XLPRUtils/pyxllib',