pyxllib 0.3.84__tar.gz → 0.3.86__tar.gz

{pyxllib-0.3.84/pyxllib.egg-info → pyxllib-0.3.86}/PKG-INFO

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

{pyxllib-0.3.84 → pyxllib-0.3.86}/pyxllib/algo/pupil.py

@@ -10,7 +10,7 @@ import math
 import re
 import sys
 
-from pyxllib.prog.newbie import typename
+from pyxllib.prog.newbie import typename, human_readable_number
 from pyxllib.text.pupil import listalign, int2myalphaenum
 
 
@@ -97,7 +97,7 @@ class ValuesStat:
     def __len__(self):
         return self.n
 
-    def summary(self, valfmt='g'):
+    def summary(self, valfmt=lambda x: human_readable_number(x, '万', 4)):
         """ 输出性能分析报告，data是每次运行得到的时间数组
 
         :param valfmt: 数值显示的格式
@@ -109,37 +109,45 @@ class ValuesStat:
             也可以传入长度5的格式清单，表示 [和、均值、标准差、最小值、最大值] 一次展示的格式
         """
         if isinstance(valfmt, str) or callable(valfmt):
-            valfmt = [valfmt] * 5
+            valfmt = [valfmt] * 6
+
+        if len(valfmt) == 5:  # 兼容旧版格式化，默认是不填充"总数"的格式化的
+            valfmt = [lambda x: x] + valfmt
+        assert len(valfmt) == 6, f'valfmt长度必须是6，现在是{len(valfmt)}'
 
         ls = []
 
-        def format_value(value, format_spec):
+        def format_value(value, fmt_id):
             """ 根据指定的格式来格式化值 """
+            format_spec = valfmt[fmt_id]
+            if format_spec is None:
+                return ''
+
             if callable(format_spec):
                 return format_spec(value)
             else:
                 return f"{value:{format_spec}}"
 
         if self.n > 1:
-            ls.append(f'总数: {self.n}')  # 注意输出其实完整是6个值，还有个总数不用控制格式
-            if valfmt[0]:
-                ls.append(f'总和: {format_value(self.sum, valfmt[0])}')
-            if valfmt[1] or valfmt[2]:
-                mean_str = format_value(self.mean, valfmt[1]) if valfmt[1] else ''
-                std_str = format_value(self.std, valfmt[2]) if valfmt[2] else ''
+            ls.append(f'总数: {format_value(self.n, 0)}')  # 注意输出其实完整是6个值，还有个总数不用控制格式
+            if valfmt[1]:
+                ls.append(f'总和: {format_value(self.sum, 1)}')
+            if valfmt[2] or valfmt[3]:
+                mean_str = format_value(self.mean, 2)
+                std_str = format_value(self.std, 3)
                 if mean_str and std_str:
                     ls.append(f'均值标准差: {mean_str}±{std_str}')
                 elif mean_str:
                     ls.append(f'均值: {mean_str}')
                 elif std_str:
                     ls.append(f'标准差: {std_str}')
-            if valfmt[3]:
-                ls.append(f'最小值: {format_value(self.min, valfmt[3])}')
             if valfmt[4]:
-                ls.append(f'最大值: {format_value(self.max, valfmt[4])}')
+                ls.append(f'最小值: {format_value(self.min, 4)}')
+            if valfmt[5]:
+                ls.append(f'最大值: {format_value(self.max, 5)}')
             return '\t'.join(ls)
         elif self.n == 1:
-            return format_value(self.sum, valfmt[0] or 'g')
+            return format_value(self.sum, valfmt[1] or 'g')
         else:
             raise ValueError("无效的数据数量")
 

{pyxllib-0.3.84 → pyxllib-0.3.86}/pyxllib/algo/stat.py

@@ -330,7 +330,7 @@ def count_key_combinations(df, col_names, count_col_name='count'):
     return df2
 
 
-def pareto_accumulate(weights, accuracy=0.01, *, print_mode=False):
+def pareto_accumulate(weights, accuracy=0.01, *, print_mode=False, value_unit_type='K'):
     """ 帕累托累计
 
     可以用来分析主要出现的权重、频次
@@ -368,9 +368,9 @@ def pareto_accumulate(weights, accuracy=0.01, *, print_mode=False):
 
     # 2 结果展示
     def fmt(p):
-        from pyxllib.text.newbie import format_big_decimal
-        ls = [f'{p[0]}it≥{format_big_decimal(p[1])}',
-              f'{format_big_decimal(p[2])}({p[2] / total_size:.0%})']
+        from pyxllib.prog.newbie import human_readable_number
+        ls = [f'{human_readable_number(p[0], "万")}条≥{human_readable_number(p[1])}',
+              f'{human_readable_number(p[2], value_unit_type)}({p[2] / total_size:.0%})']
         return '，'.join(map(str, ls))
 
     total_size = points[-1][2]

{pyxllib-0.3.84 → pyxllib-0.3.86}/pyxllib/data/echarts.py

@@ -104,27 +104,25 @@ class XlBar(Bar):
 inject_members(XlBar, Bar)
 
 
-def get_render_body(chart):
-    """ 得到渲染后的核心html内容 """
-    from pyxllib.text.nestenv import NestEnv
-
-    # 1 得到完整的html内容
-    file = XlPath.tempfile(suffix='.html')
-    chart.render(path=str(file))
-    res = file.read_text()
-    file.delete()
-
-    # 2 得到body核心内容
-    res = NestEnv(res).xmltag('body', inner=True).string()
-
-    return res
-
-
 def render_echart_html(title='Awesome-pyecharts', body=''):
     from pyxllib.text.xmllib import get_jinja_template
     return get_jinja_template('echart_base.html').render(title=title, body=body)
 
 
+# 绘制帕累托累计图
+def draw_pareto_chart(data, accuracy=0.1, *, title='帕累托累积权重', value_unit_type='K'):
+    from pyxllib.algo.stat import pareto_accumulate
+    pts, labels = pareto_accumulate(data, accuracy=accuracy, value_unit_type=value_unit_type)
+    x = Line()
+    x.add_series(title, pts, labels=labels, label={'position': 'right'})
+    x.set_global_opts(
+        # x轴末尾要故意撑大一些，不然有部分内容会显示不全
+        xaxis_opts=opts.AxisOpts(name='条目数', max_=int(float(f'{pts[-1][0]*1.2:.2g}'))),
+        yaxis_opts=opts.AxisOpts(name='累积和')
+    )
+    return x
+
+
 if __name__ == '__main__':
     with TicToc(__name__):
         pass

{pyxllib-0.3.84 → pyxllib-0.3.86}/pyxllib/data/pglib.py

@@ -70,7 +70,7 @@ class Connection(psycopg.Connection, SqlBase):
         """ 【查】表格有哪些字段
         """
         cmd = f"SELECT column_name FROM information_schema.columns WHERE table_name='{table_name}'"
-        return list(self.exec_col(cmd))
+        return self.exec2col(cmd)
 
     def ensure_column(self, table_name, col_name, *args, comment=None, **kwargs):
         super(Connection, self).ensure_column(table_name, col_name, *args, **kwargs)
@@ -401,7 +401,7 @@ class XlprDb(Connection):
         TODO 功能还可以增加：gpu显卡温度、硬盘读写速率检查、网络上传下载带宽
         """
         # 1 服务器列表
-        host_names = list(self.exec_col('SELECT host_name FROM hosts WHERE id > 1 ORDER BY id'))
+        host_names = self.exec2col('SELECT host_name FROM hosts WHERE id > 1 ORDER BY id')
         host_cpu_gb = {h: v for h, v in self.execute('SELECT host_name, cpu_gb FROM hosts')}
 
         # 2 去所有服务器取使用情况
@@ -466,7 +466,6 @@ class XlprDb(Connection):
         :param list ls: n*3，第1列是时间，第2列是总值，第3列是每个用户具体的数据
         """
         from pyecharts.charts import Line
-        from pyxllib.data.echarts import get_render_body
 
         map_user_name = {}
         for ks, v in self.execute('SELECT account_names, name FROM users'):
@@ -516,7 +515,7 @@ class XlprDb(Connection):
                              to_list([x[2].get(user, 0) for x in ls]),
                              areaStyle={}, stack='Total', emphasis={'focus': 'series'})
 
-        return get_render_body(chart), sum(all_users_usaged.values())
+        return '<body>' + chart.render_embed() + '</body>', sum(all_users_usaged.values())
 
     def dbview_cpu(self, recent=datetime.timedelta(days=1), date_trunc='hour'):
         from pyxllib.data.echarts import render_echart_html

{pyxllib-0.3.84 → pyxllib-0.3.86}/pyxllib/data/sqlite.py

@@ -5,6 +5,7 @@
 # @Date   : 2022/04/12 08:59
 
 import json
+import re
 import sqlite3
 
 import pandas as pd
@@ -106,13 +107,24 @@ class SqlBase:
     def __3_execute(self):
         pass
 
-    def exec_col(self, *args, **kwargs):
-        """ 获得第1列的值，注意这个方法跟select_col很像，但更泛用，优先推荐使用exec_col
+    def exec2one(self, *args, **kwargs):
+        """ 获得第1行的值 """
+        return self.execute(*args, **kwargs).fetchone()[0]
 
-        >> self.exec_col('SELECT id FROM skindata')
-        """
-        for row in self.execute(*args, **kwargs):
-            yield row[0]
+    def exec2row(self, *args, **kwargs):
+        """ 获得第1行的值 """
+        return self.execute(*args, **kwargs).fetchone()
+
+    def exec2col(self, *args, **kwargs):
+        """ 获得第1列的值 """
+        return [row[0] for row in self.execute(*args, **kwargs).fetchall()]
+
+    # 兼容旧接口
+    exec_col = exec2col
+
+    def exec2df(self, *args, **kwargs):
+        """ 获得pandas.DataFrame类型的返回值 """
+        return pd.read_sql(*args, self, **kwargs)
 
     def __4_数据类型(self):
         pass
@@ -158,8 +170,10 @@ class SqlBase:
 
     def select_col(self, table_name, col):
         """ 获得一列数据，常使用的功能，所以做了一个封装
+
+        注意，"exec"前缀的方法一般返回的是迭代器，而"select"前缀获得一般是直接的全部列表、结果
         """
-        return [x[0] for x in self.execute(f'SELECT {col} FROM {table_name}').fetchall()]
+        return self.exec2col(f'SELECT {col} FROM {table_name}')
 
     def group_count(self, table_name, cols, count_column_name='cnt'):
         """ 【查】分组统计各组值组合出现次数
@@ -177,6 +191,53 @@ class SqlBase:
         df = pd.DataFrame.from_records(records, columns=cols.split(',') + [count_column_name])
         return df
 
+    def get_count_by_altering_query(self, data_query: str) -> int:
+        """
+        从给定的SQL SELECT查询中获取行数计数。这个方法通过修改原始的SELECT查询，
+        将其转换为一个COUNT查询来实现计数。这种方法特别适用于在获取大量数据之前，
+        需要预估数据量的场景。
+
+        问题背景：
+        在进行大规模数据处理前，了解数据的规模可以帮助进行更有效的资源分配和性能优化。
+        传统的做法是分两步执行：首先计算数据总量，然后再执行实际的数据提取。
+        这个函数旨在通过单个查询来简化这一流程，减少数据库的负载和响应时间。
+
+        实现机制：
+        函数首先使用正则表达式识别出SQL查询的FROM关键词，这是因为无论SELECT查询的复杂程度如何，
+        计数的核心都是保留FROM及其后面的表和条件语句。然后，它构造一个新的COUNT查询，
+        替换原始查询中的SELECT部分。最后，函数执行这个新的查询并返回结果。
+
+        :param data_query (str): 原始的SQL SELECT查询字符串。
+        :return int: 查询结果的行数。
+
+        示例:
+        >> sql = SqlBase()
+        >> query = "SELECT id, name FROM users WHERE active = True"
+        >> count = sql.get_count_by_altering_query(query)
+        >> print(count)
+        45
+
+        注意:
+        - 这个函数假设输入的是合法的SQL SELECT查询。
+        - 函数依赖于数据库连接的execute方法能够正确执行转换后的COUNT查询。
+        - 在一些复杂的SQL查询中，特别是包含子查询、特殊函数或复杂的JOIN操作时，
+          请确保转换后的计数查询仍然有效。
+        """
+        # 使用正则表达式定位'FROM'（考虑各种大小写情况），并确保它前后是空格或语句的开始/结束
+        match = re.search(r'\bFROM\b', data_query, flags=re.IGNORECASE)
+        if match:
+            from_index = match.start()
+            count_query = 'SELECT COUNT(*) ' + data_query[from_index:]  # 构造计数查询
+            try:
+                result = self.execute(count_query).fetchone()  # 执行查询
+                return result[0] if result else 0  # 返回计数结果
+            except Exception as e:
+                print(f"Error executing count query: {e}")
+                return 0
+        else:
+            print("No 'FROM' keyword found in the data query.")
+            return 0
+
 
 class Connection(sqlite3.Connection, SqlBase):
     """
@@ -219,12 +280,12 @@ class Connection(sqlite3.Connection, SqlBase):
     def __3_execute(self):
         pass
 
-    def exec_nametuple(self, *args, **kwargs):
+    def exec2nametuple(self, *args, **kwargs):
         cur = self.cursor()
         cur.row_factory = sqlite3.Row
         return cur.execute(*args, **kwargs)
 
-    def exec_dict(self, *args, **kwargs):
+    def exec2dict(self, *args, **kwargs):
         """ execute基础上，改成返回值为dict类型 """
 
         def dict_factory(cursor, row):
@@ -237,6 +298,9 @@ class Connection(sqlite3.Connection, SqlBase):
         cur.row_factory = dict_factory
         return cur.execute(*args, **kwargs)
 
+    # 兼容老版本
+    exec_dict = exec2dict
+
     def __4_数据类型(self):
         pass
 

{pyxllib-0.3.84 → pyxllib-0.3.86}/pyxllib/file/specialist/filelib.py

@@ -1600,7 +1600,7 @@ class XlPath(type(pathlib.Path())):
             ext = '.' + t.extension
             ext0 = file_path.suffix
 
-            if ext0 in ('.docx', '.xlsx', '.pptx'):
+            if ext0 in ('.docx', '.xlsx', '.pptx', '.xlsm'):
                 ext0 = '.zip'
             elif ext0 in ('.JPG', '.jpeg'):
                 ext0 = '.jpg'
@@ -1751,7 +1751,8 @@ class XlPath(type(pathlib.Path())):
 
         # 六 文件配对
         if run_mode >= 6:
-            printf('\n六、文件配对（检查每个目录里stem名称是否配对，列出文件组成不单一的目录结构，请重点检查落单未配对的情况）')
+            printf(
+                '\n六、文件配对（检查每个目录里stem名称是否配对，列出文件组成不单一的目录结构，请重点检查落单未配对的情况）')
             prompt = False
             for root, dirs, files in os.walk(self):
                 suffix_counts = defaultdict(list)
@@ -1877,6 +1878,7 @@ class XlPath(type(pathlib.Path())):
             这个不仅用于分组，返回的字符串，也会作为字典序排序的依据，如果想用自然序，记得加natural_sort_key进行转换
         :param batch_name: 设置batch的名称，默认 'batch{}'
         :param bias: 希望用不到这个参数，只有中途出bug，需要继续处理的时候，用来自动增加编号
+            注意默认就是从1开始编号的，比如bias设成8的话，实际是从9开始编号的
         :param tail_limit: 限制数量少于多少的batch，合并到上一个batch中
         """
         from pyxllib.algo.pupil import Groups
@@ -1974,28 +1976,55 @@ class XlPath(type(pathlib.Path())):
             dst_dir.mkdir(parents=True, exist_ok=True)
 
     # 无法选定文件
-    def _move_selectable(self, dst_dir):
+    def _move_selectable(self, dst_dir, *, print_mode=False):
         """ 目录功能，将目录下可选中的文件移动到目标目录
 
-        1、要理解这个看似有点奇怪的功能，需要理解，在数据处理中，可能会拿到超长文件名的文件，
+        1、要理解这个看似有点奇怪的功能，需要了解一个背景，在数据处理中，可能会拿到超长文件名的文件，
             这种在windows平台虽然手动可以操作，但在代码中，会glob不到，强制指定也会说文件不存在
         2、为了解决这类文件问题，一般需要对其进行某种规则的重命名。因为linux里似乎不会限制文件名长度，所以要把这些特殊文件打包到linux里处理。
         3、因为这些文件本来就无法被选中，所以只能反向操作，将目录下的可选中文件移动到目标目录。
         """
-        for p in self.glob('*'):
-            if p.exists():
-                p.move(dst_dir / p.name)
+        for p in tqdm(self.glob('*'), disable=not print_mode):
+            # 231211周一16:03 一般本来就glob不到，现在的p就是存在的，但是可能以防万一加的捕捉，我现在也不敢删
+            if p.is_file():
+                try:
+                    p.move(dst_dir / p.name)
+                except FileNotFoundError:
+                    continue
 
-    def move_unselectable(self, dst_dir):
+    def move_unselectable(self, dst_dir, *, print_mode=False):
         """ 见_move_selectable，因为无法对这些特殊文件进行移动
         所以这里只是对_move_selectable的封装，中间通过文件重命名，来伪造移动了无法选中文件的操作效果
         """
         tempdir = self.create_tempdir_path(dir=self.parent)
         tempdir.mkdir(exist_ok=True)
-        self._move_selectable(tempdir)
+        self._move_selectable(tempdir, print_mode=print_mode)
         self.rename2(dst_dir)
         tempdir.move(self)
 
+    def rename_stem_until_not_exists(self):
+        """ 比较高级的一个操作，会按照某种规则不断重命名，直到是当前并不存在的文件名，常用在文件拷贝避免重名冲突等场景
+
+        todo 写个支持自定义规则的输出参数？
+        todo 有个首次要不要判断exists的问题，可能跟不同的业务场景有关，要思考怎么设计更好...
+        """
+
+        def add_stem(m):
+            a = int(m.group(1)) + 1
+            return f'({a})'
+
+        file = self
+        while file.exists():
+            stem = file.stem
+            m = re.search(r'\(\d+\)$', stem)
+            if m:  # 已经有目标范式的编号，继续累加
+                stem = re.sub(r'\((\d+)\)$', add_stem, stem)
+            else:  # 还没有编号的，直接从'2'开始编号
+                stem += ' (2)'
+            file = self.with_stem(stem.strip())  # 忽略最后空白，这个很容易出问题
+
+        return file
+
 
 def demo_file():
     """ File类的综合测试"""
@@ -2506,3 +2535,81 @@ class TwinDirs:
     def copy_dir_structure(self):
         """ 复制目录结构 """
         self.src_dir.copy_dir_structure(self.dst_dir)
+
+
+class BatchFileRenamer:
+    """ 对一批数据，按照某种规则判重、重命名去重
+    一般是对stem重命名后，确保数据随意混合后名称也不会有出现重复
+    """
+
+    def __init__(self, _dir=None):
+        """
+        :param _dir: 输入待处理的第一个目录
+        """
+        # 所有待处理的文件
+        self.files = []
+        if _dir is not None:
+            self.add_dir(_dir)
+
+    def add_dir(self, _dir):
+        """ 添加一个目录下的所有文件
+        如果有比较零散的文件待处理，可以直接操作self.files
+
+        todo 目录的重命名？如果引入目录的重命名，算法会复杂非常多的，这个暂不考虑。
+        """
+        for f in XlPath(_dir).rglob_files():
+            self.files.append(f)
+
+    def get_key(self, file):
+        """ 计算一个文件的重复标识，不同文件之间的判重依据 """
+        # 默认的key，规则会比较严，stem不重复，大小写不重复
+        return file.stem.lower()
+
+    def get_new_name(self, file, exists_keys=None):
+        """ 输入的f必须是已经确定要进行重命名的文件
+
+        对于windows来说
+            是先假定在一个组中，增加编号
+            如果编号的文件已经存在，则换一个新的命名组
+
+        对我这里来说，就不搞这么复杂了，就是无脑加编号就行
+        """
+
+        def add_stem(m):
+            a = int(m.group(1)) + 1
+            return f'({a})'
+
+        stem = file.stem
+        while True:
+            m = re.search(r'\(\d+\)$', stem)
+            if m:  # 已经有目标范式的编号，继续累加
+                stem = re.sub(r'\((\d+)\)$', add_stem, stem)
+            else:  # 还没有编号的，直接从'2'开始编号
+                stem += ' (2)'
+
+            f2 = file.with_stem(stem.strip())  # 忽略最后空白，这个很容易出问题
+            k2 = self.get_key(f2)
+            if k2 not in exists_keys:  # 如果新的命名不会跟旧有文件有任何重复，循环就可以终止了
+                exists_keys.add(k2)
+                return f2
+
+    def rename_files(self, print_mode=False, exists_keys=None):
+        """ 对文件进行批量重命名 """
+        # 1 先遍历一遍文件，确认哪些文件是确定要重命名的
+        exists_keys = exists_keys or set()
+        repeat_name_files = []  # 确认要进行重命名的文件
+        for f in self.files:
+            k = self.get_key(f)
+            if k not in exists_keys:
+                exists_keys.add(k)
+            else:
+                repeat_name_files.append(f)
+
+        # 2 对需要重命名的文件进行操作
+        cnt = 0
+        for f in repeat_name_files:
+            cnt += 1
+            f2 = self.get_new_name(f, exists_keys)
+            if print_mode:
+                print(cnt, f.as_posix(), '-->', f2.name)
+            f.rename2(f2)