pyxllib 0.3.101__tar.gz → 0.3.103__tar.gz

{pyxllib-0.3.101/pyxllib.egg-info → pyxllib-0.3.103}/PKG-INFO

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

pyxllib-0.3.103/pyxllib/data/jsonlib.py

@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# @Author : 陈坤泽
+# @Email  : 877362867@qq.com
+# @Date   : 2024/04/01
+
+from collections import Counter
+
+from pyxllib.prog.pupil import check_install_package
+
+check_install_package('jmespath')
+
+import jmespath
+
+
+class JsonTool:
+    @classmethod
+    def find_paths_by_condition(cls, obj, condition, current_path=''):
+        """
+        根据提供的条件递归搜索JSON对象，查找满足条件的路径。
+        """
+        if isinstance(obj, dict):
+            for k, v in obj.items():
+                new_path = f"{current_path}.{k}" if current_path else k
+                if condition(k, v):
+                    yield new_path
+                else:
+                    if isinstance(v, (dict, list)):
+                        yield from JsonTool.find_paths_by_condition(v, condition, new_path)
+        elif isinstance(obj, list):
+            for index, item in enumerate(obj):
+                new_path = f"{current_path}[{index}]"
+                if isinstance(item, (dict, list)):
+                    yield from JsonTool.find_paths_by_condition(item, condition, new_path)
+
+    @classmethod
+    def find_paths_with_key(cls, obj, key, current_path=''):
+        """
+        查找包含指定键名的路径。
+        """
+        # 定义一个简单的条件函数，仅基于键名
+        condition = lambda k, v: k == key
+        return JsonTool.find_paths_by_condition(obj, condition, current_path)
+
+
+class JsonlTool:
+    @classmethod
+    def check_key_positions(cls, json_list, key):
+        """
+        在JSON对象列表中统计每种包含指定键名的路径出现的次数。
+
+        :param json_list: 包含多个JSON对象的列表。
+        :param key: 要查找的键名。
+        :return: 一个Counter对象，统计每种路径出现的次数。
+        """
+        paths_counter = Counter()
+        for json_obj in json_list:
+            # 使用JsonTool查找当前对象中包含指定键的路径
+            paths = list(JsonTool.find_paths_with_key(json_obj, key))
+            paths_counter.update(paths)
+
+        return paths_counter
+
+    @classmethod
+    def check_path_values(cls, json_list, jmespath_expression, value_extractor=lambda x: x):
+        """
+        根据提供的jmespath表达式，在JSON对象列表中直接统计表达式取值的次数。
+        支持自定义函数来获取要统计的键。
+
+        :param json_list: 包含多个JSON对象的列表。
+        :param jmespath_expression: 要应用的jmespath表达式。
+        :param value_extractor: 一个函数，用于从jmespath.search的结果中提取要统计的值。
+        :return: 一个Counter对象，统计提取值出现的次数。
+        """
+        values_counter = Counter()
+        for json_obj in json_list:
+
+            # 使用jmespath搜索当前对象
+            result = jmespath.search(jmespath_expression, json_obj)
+            # 使用自定义的value_extractor函数提取要统计的值
+            extracted_values = value_extractor(result)
+            if not isinstance(extracted_values, list):
+                extracted_values = [extracted_values]
+
+            for value in extracted_values:
+                values_counter[value] += 1
+
+        values_counter = Counter(dict(values_counter.most_common()))
+        return values_counter

{pyxllib-0.3.101 → pyxllib-0.3.103}/pyxllib/ext/JLineViewer.py

@@ -390,9 +390,22 @@ class JLineViewer(QMainWindow):
         if parent is None:
             parent = QStandardItemModel()
             parent.setHorizontalHeaderLabels(['Key', 'Value'])
+
+        # if isinstance(data, dict):
+        #     for key, value in data.items():
+        #         self.dataToModel(key, value, parent)
+
+        # 判断数据类型，并相应处理
         if isinstance(data, dict):
             for key, value in data.items():
                 self.dataToModel(key, value, parent)
+        elif isinstance(data, list):
+            # 处理列表：创建一个无key的父项，将列表元素作为子项添加
+            self.dataToModel("List", data, parent)
+        else:
+            # 处理基本数据类型：创建一个单独的条目
+            self.dataToModel("Value", data, parent)
+
         return parent
 
     def dataToModel(self, key, value, parent):
@@ -476,7 +489,7 @@ def start_jlineviewer(fname=None):
     if isinstance(fname, list):  # 可以输入一个list字典数据，会转存到临时目录里查看
         tempfile = XlPath.tempfile(suffix='.jsonl')
         tempfile.write_jsonl(fname)
-        fname = tempfile
+        fname = tempfile.as_posix()
     if fname:
         ex.showDialog(fname=fname)
     sys.exit(app.exec_())

{pyxllib-0.3.101 → pyxllib-0.3.103}/pyxllib/ext/robustprocfile.py

@@ -10,14 +10,19 @@
 半定制化的功能组件
 """
 
+from pyxllib.prog.pupil import check_install_package
+
+check_install_package('joblib')
+
 from collections import defaultdict, Counter
 import datetime
 import re
 import json
 
 from tqdm import tqdm
+from joblib import Parallel, delayed
 
-from pyxllib.prog.pupil import check_counter, tprint
+from pyxllib.prog.pupil import check_counter, tprint, typename
 from pyxllib.file.specialist import XlPath, refinepath
 
 
@@ -232,8 +237,9 @@ class CacheJsonlFile:
     def save_all(self):
         """ 最终存储的文件名 """
         self.flush()
-        dst_file = self.cache_file.with_stem(f'{self.prefix_stem}_{self.tag}{self.total}_{get_timestamp()}')
-        self.cache_file.rename(dst_file)
+        if self.cache_file.is_file():
+            dst_file = self.cache_file.with_stem(f'{self.prefix_stem}_{self.tag}{self.total}_{get_timestamp()}')
+            self.cache_file.rename(dst_file)
 
 
 class CacheJsonlGroupFiles:
@@ -274,7 +280,15 @@ def process_single_file(root,
                         total=None,
                         if_exists='skip',
                         group_func=None,
-                        batch_size=2000):
+                        batch_size=2000,
+                        debug=False,
+                        show_tqdm=False):
+    def finished():
+        if total:
+            tprint(f'处理第{cur_idx}/{total}个文件：{infile.name} ==> {tag}')
+        else:
+            tprint(f'处理文件：{infile.name} ==> {tag}')
+
     # 1 缓存路径
     srcdir = XlPath(root)
     infile = XlPath.init(infile, root=srcdir)
@@ -284,13 +298,25 @@ def process_single_file(root,
     errdir = srcdir.parent / f'{srcdir.name}_{tag}error' / relpath.parent
 
     # 2 判断是不是已处理过的文件
-    stem = re.split(r'\d+_\d{14}', relpath.stem)[0]
-    dstfiles = list(dstdir.glob_files(f'{stem}*'))
-    errfiles = list(errdir.glob_files(f'{stem}*'))
+    # stem = re.split(r'\d+_\d{14}', relpath.stem)[0]
+    stem = relpath.stem + f'_{tag}'
+    dstfiles = list(dstdir.glob_files(f'{stem}*.jsonl'))
+    errfiles = list(errdir.glob_files(f'{stem}*.jsonl'))
+
+    # 需要进一步过滤
+    def is_exists_old_file(f):
+        if f.name.endswith('.cache.jsonl'):
+            return False
+        stem2 = f.name[len(stem):]
+        if re.match(r'(error)?\d+_\d{14}.jsonl$', stem2):
+            return True
+
     # cache文件不算，不用管
-    check_files = [f for f in (dstfiles + errfiles) if not f.name.endswith('.cache.jsonl')]
+    check_files = [f for f in (dstfiles + errfiles) if is_exists_old_file(f)]
+
     if check_files:
         if if_exists == 'skip':
+            finished()
             return
         elif if_exists == 'overwrite':
             for f in check_files:
@@ -298,22 +324,174 @@ def process_single_file(root,
         elif if_exists == 'error':
             raise FileExistsError(f'目标文件已存在：{check_files}')
         else:
+            finished()
             return
 
     # 3 处理数据
+    if debug:  # 如果开启调试模式，则关闭分组功能
+        group_func = None
     dstcgf = CacheJsonlGroupFiles(dstdir, infile.stem, tag, group_func, batch_size)
     errcgf = CacheJsonlGroupFiles(errdir, infile.stem, tag + 'error', batch_size=batch_size)
+    if debug:  # 如果开启调试模式，则单独分错误文件
+        errcgf = dstcgf
 
-    for line in tqdm(infile.yield_line(), disable=total):
+    for line in tqdm(infile.yield_line(), desc=f'{infile.name} ==> {tag}', disable=not show_tqdm):
+        # todo 出错的数据，应该添加错误信息，也存成一个新的jsonl格式
         row = row_func(line)
-        if row:
+        if row and (not isinstance(row, dict) or row.get('status', 'ok') == 'ok'):
+            # 必须要有内容，但如果内容有个status字段且不是'ok'，也不能要
             dstcgf.append([row])
         else:
-            errcgf.append([line])
+            # 注意旧版存储的事line，但是新版的存储成row了
+            # 但如果row确实没内容，还是兼容旧版，存储line
+            errcgf.append([row or line])
 
     dstcgf.save_all()
     errcgf.save_all()
-    if total:
-        tprint(f'处理第{cur_idx}/{total}个文件：{infile.name} ==> {tag}')
+    finished()
+
+
+class StructureAnalyzer:
+    @classmethod
+    def item_to_json(cls, x, depth):
+        """ 获得字典结构的签名
+
+        todo 这个项目之后，可以对这个函数进一步优化精简，作为以后解析结构的一个通用工具
+        """
+        if depth <= 0:
+            return typename(x)
+
+        if isinstance(x, dict):
+            d = {}
+            keys = sorted(x.keys())
+            for k in keys:
+                d[k] = cls.item_to_json(x[k], depth - 1)
+        elif isinstance(x, list):
+            d = []
+            for k in x:
+                d.append(cls.item_to_json(k, depth - 1))
+        else:
+            d = typename(x)
+
+        return d
+
+    @classmethod
+    def item_to_str(cls, x, depth):
+        res = cls.item_to_json(x, depth)
+        return json.dumps(res)
+
+    @classmethod
+    def group_items(cls, items, depth):
+        ct = Counter()
+        groups = defaultdict(list)
+        for x in items:
+            desc = cls.item_to_str(x, depth)
+            ct[desc] += 1
+            groups[desc].append(x)
+        # 按照值的数量对groups排序
+        groups = dict(sorted(groups.items(), key=lambda x: -len(x[1])))
+        return groups
+
+    @classmethod
+    def get_items_structures(cls, items, savefile=None):
+        """ 获取jsonl数据的结构分布
+
+        :param list[json] items: 一组json数据
+        :return list[json]: 统计每种结构的分布数量，按树形结构，从多到少排序展示
+        """
+
+        def add_group(parent, items, depth, res):
+            tag = parent['depth'] if parent else ''
+            groups = cls.group_items(items, depth)
+            for i, (desc, items2) in enumerate(groups.items(), start=1):
+                if desc == parent['desc']:  # 再细化的结果跟父结点相同时，不再加深层级
+                    continue
+
+                d = {}
+                d['depth'] = f'{tag}-{i}' if tag else f'{i}'
+                d['count'] = len(items2)
+                d['desc'] = desc
+                d['structure'] = cls.item_to_json(items2[0], depth)
+                res.append(d)
+
+                add_group(d, items2, depth + 1, res)
+
+        res = []  # 初始化结果列表
+        add_group({'depth': '', 'desc': ''}, items, 1, res)  # 从空标签开始递归
+
+        if savefile:
+            XlPath(savefile).write_jsonl(res)
+
+        return res
+
+    @classmethod
+    def compare_keys(cls, items):
+        """ 对从 get_items_structures 获得的数据，对比structure的覆盖情况 """
+        import pandas as pd
+        from pyxllib.algo.stat import custom_fillna
+
+        ls = []
+        for x in items:
+            row = {}
+            row['__depth'] = x['depth']
+            row['__count'] = x['count']
+            if isinstance(x['structure'], dict):
+                row.update(x['structure'])
+            elif isinstance(x['structure'], list):
+                row.update({f'[{k}]': v for k, v in enumerate(x['structure'])})
+            ls.append(row)
+
+        df = pd.DataFrame.from_dict(ls)
+        # 筛选df，depth中没有'-'
+        df = df[df['__depth'].apply(lambda x: '-' not in x)]
+        df = custom_fillna(df).T
+
+        return df
+
+
+def process_batch_files(srcdir,
+                        dsttag,
+                        line_convert_func,
+                        pattern='*.jsonl',
+                        if_exists='skip',
+                        processes_num=1,
+                        group_func=None,
+                        batch_size=2000,
+                        debug=False,
+                        ):
+    """ 通用批处理函数
+
+    :param srcdir: 输入待处理的目录或文件
+    :param pattern: 文件名检索逻辑，如 '*'，'*.jsonl', '*_std*.jsonl'等
+    :param if_exists: 如果目标文件已存在，如何处理。'skip'跳过不重复处理，'overwrite'覆盖重新运行，'error'抛出报错
+    :param processes_num: 并发处理的进程数
+    :param batch_size: 每个文件缓存的条目数，超过这个数目后就会先写入文件
+    """
+    # 1 检索文件
+    srcdir = XlPath(srcdir)
+    if srcdir.is_file():
+        files = [srcdir.name]
+        srcdir = srcdir.parent
     else:
-        tprint(f'处理文件：{infile.name} ==> {tag}')
+        files = [f.relpath(srcdir) for f in srcdir.rglob_files(pattern)]
+
+    file_num = len(files)
+
+    # 2 并发处理多个文件
+    backend = 'loky' if processes_num > 1 else 'sequential'
+    tasks = []
+    for i, f in enumerate(files, start=1):
+        task = delayed(process_single_file)(srcdir,
+                                            f,
+                                            dsttag,
+                                            line_convert_func,
+                                            cur_idx=i,
+                                            total=file_num,
+                                            if_exists=if_exists,
+                                            group_func=group_func,
+                                            batch_size=batch_size,
+                                            debug=debug,
+                                            show_tqdm=processes_num == 1)
+        tasks.append(task)
+
+    Parallel(n_jobs=processes_num, backend=backend)(tasks)

{pyxllib-0.3.101 → pyxllib-0.3.103}/pyxllib/ext/utools.py

@@ -222,6 +222,19 @@ class UtoolsFile(UtoolsBase):
         from pyxllib.ext.JLineViewer import start_jlineviewer
         start_jlineviewer(self.paths[0].as_posix())
 
+    def open_jsonl_with_excel(self):
+        """ 用excel打开jsonl文件 """
+        from pyxllib.algo.stat import write_dataframes_to_excel
+
+        file = self.paths[0].as_posix()
+        data = XlPath(file).read_jsonl()
+
+        file = XlPath.create_tempfile_path('.xlsx')
+        df = pd.DataFrame.from_dict(data)
+        write_dataframes_to_excel(file, {'Sheet1': df})
+
+        os.startfile(file)
+
 
 class UtoolsText(UtoolsBase):
 

{pyxllib-0.3.101 → pyxllib-0.3.103/pyxllib.egg-info}/PKG-INFO

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

{pyxllib-0.3.101 → pyxllib-0.3.103}/pyxllib.egg-info/SOURCES.txt

@@ -34,6 +34,7 @@ pyxllib/cv/xlcvlib.py
 pyxllib/cv/xlpillib.py
 pyxllib/data/__init__.py
 pyxllib/data/echarts.py
+pyxllib/data/jsonlib.py
 pyxllib/data/oss.py
 pyxllib/data/pglib.py
 pyxllib/data/sqlite.py

{pyxllib-0.3.101 → pyxllib-0.3.103}/setup.py

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