pyxllib 0.3.109__tar.gz → 0.3.111__tar.gz

{pyxllib-0.3.109/pyxllib.egg-info → pyxllib-0.3.111}/PKG-INFO

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

{pyxllib-0.3.109 → pyxllib-0.3.111}/pyxllib/algo/pupil.py

@@ -6,8 +6,10 @@
 
 from bisect import bisect_right
 from collections import defaultdict, Counter
+import datetime
 import math
 import re
+from statistics import quantiles
 import sys
 import textwrap
 
@@ -161,6 +163,7 @@ class ValuesStat2:
         from statistics import pstdev, mean
 
         # 支持输入可能带有非数值类型的raw_values
+        data_type = data_type or ''
         if raw_values:
             if 'timestamp' in data_type:
                 values = [x.timestamp() for x in raw_values if hasattr(x, 'timestamp')]
@@ -194,7 +197,8 @@ class ValuesStat2:
     def __len__(self):
         return self.n
 
-    def summary(self, unit=None, precision=4, percentile_count=5):
+    def _summary(self, unit=None, precision=4, percentile_count=5):
+        """ 返回字典结构的总结 """
         """ 文本汇总性的报告
 
         :param percentile_count: 包括两个极值端点的切分点数，
@@ -204,8 +208,6 @@ class ValuesStat2:
         :param unit: 展示数值时使用的单位
         :param precision: 展示数值时的精度
         """
-        import datetime
-        from statistics import quantiles
 
         # 1 各种细分的格式化方法
         def fmt0(v):
@@ -238,19 +240,20 @@ class ValuesStat2:
             fmt = fmtb = fmt1
 
         # 2 生成统计报告
-        desc = []
+        desc = {}
         if self.raw_n and self.raw_n > self.n:
-            desc.append(f"非数值数量：{fmt0(self.raw_n - self.n)}")
+            desc["总数"] = f"{fmt0(self.n)}/{fmt0(self.raw_n)}≈{self.n / self.raw_n:.2%}"
+        else:
+            desc["总数"] = f"{fmt0(self.n)}"
 
-        desc.append(f"总数：{fmt0(self.n)}")
         if self.sum is not None:
-            desc.append(f"总和：{fmt(self.sum)}")
+            desc["总和"] = f"{fmt(self.sum)}"
         if self.mean is not None and self.std is not None:
-            desc.append(f'均值±标准差：{fmt(self.mean)}±{fmtb(self.std)}')
+            desc["均值±标准差"] = f"{fmt(self.mean)}±{fmtb(self.std)}"
         elif self.mean is not None:
-            desc.append(f'均值：{fmt(self.mean)}')
+            desc["均值"] = f"{fmt(self.mean)}"
         elif self.std is not None:
-            desc.append(f'标准差：{fmtb(self.std)}')
+            desc["标准差"] = f"{fmtb(self.std)}"
 
         if self.values:
             dist = [self.values[0]]
@@ -259,11 +262,24 @@ class ValuesStat2:
                 dist += quartiles
             dist.append(self.values[-1])
 
-            desc.append(f"分布：{'/'.join([fmt(v) for v in dist])}")
-        elif self.dist:  # 此时当前函数的percentile设置失效，以dist中存储的情况为准
-            desc.append(f"分布：{'/'.join([fmt(v) for v in self.dist])}")
+            desc["分布"] = '/'.join([fmt(v) for v in dist])
+        elif self.dist:
+            desc["分布"] = '/'.join([fmt(v) for v in self.dist])
 
-        return '\t'.join(desc)
+        return desc
+
+    def summary(self, unit=None, precision=4, percentile_count=5):
+        """ 文本汇总性的报告
+
+        :param percentile_count: 包括两个极值端点的切分点数，
+            设置2，就是不设置分位数，就是只展示最小、最大值
+            如果设置了3，就表示"中位数、二分位数"，在展示的时候，会显示50%位置的分位数值
+            如果设置了5，就相当于"四分位数"，会显示25%、50%、75%位置的分位数值
+        :param unit: 展示数值时使用的单位
+        :param precision: 展示数值时的精度
+        """
+        desc = self._summary(unit, precision, percentile_count)
+        return '\t'.join([f"{key}: {value}" for key, value in desc.items()])
 
     def calculate_ratios(self, x_values, fmt=False):
         """ 计算并返回一个字典，其中包含每个 x_values 中的值与其小于等于该值的元素的比例

{pyxllib-0.3.109 → pyxllib-0.3.111}/pyxllib/data/pglib.py

@@ -45,8 +45,8 @@ from pyxllib.prog.newbie import round_int
 from pyxllib.prog.pupil import utc_now, utc_timestamp
 from pyxllib.prog.specialist import XlOsEnv
 from pyxllib.algo.pupil import ValuesStat2
-from pyxllib.file.specialist import get_etag
-from pyxllib.data.sqlite import SqlBase, SQLBuilder
+from pyxllib.file.specialist import get_etag, StreamJsonlWriter
+from pyxllib.data.sqlite import SqlBase, SqlBuilder
 
 
 class Connection(psycopg.Connection, SqlBase):
@@ -154,15 +154,19 @@ WHERE {table_name}.{item_id_name} = cte.{item_id_name}"""
             第1个值，是一个迭代器，看起来仍然能一条一条返回，实际后台是按照batch_size打包获取的
             第2个值，是数据总数
         """
-        if not isinstance(sql, SQLBuilder):
+        if not isinstance(sql, SqlBuilder):
             raise ValueError('暂时只能搭配SQLBuilder使用')
 
         num = self.exec2one(sql.build_count())
-        cur = self.exec2dict(sql.build_select(), **kwargs)
+        offset = 0
 
         def yield_row():
+            nonlocal offset
             while True:
-                rows = cur.fetchmany(batch_size)
+                sql2 = sql.copy()
+                sql2.limit(batch_size, offset)
+                rows = self.exec2dict(sql2.build_select(), **kwargs).fetchall()
+                offset += batch_size
                 if not rows:
                     break
                 yield from rows
@@ -191,8 +195,10 @@ WHERE {table_name}.{item_id_name} = cte.{item_id_name}"""
             return 'boolean'
         elif isinstance(val, float):
             return 'float4'
-        elif isinstance(val, dict):
+        elif isinstance(val, (dict, list)):
             return 'jsonb'
+        elif isinstance(val, datetime.datetime):
+            return 'timestamp'
         else:  # 其他list等类型，可以用json.dumps或str转文本存储
             return 'text'
 
@@ -256,42 +262,42 @@ WHERE {table_name}.{item_id_name} = cte.{item_id_name}"""
     def __6_高级统计(self):
         pass
 
-    def get_field_valuesstat(self, table_name, field_name, percentile_count=5,
-                             filter_condition=None, by_data=False):
+    def get_column_valuesstat(self, table_name, column, percentile_count=5,
+                              filter_condition=None, by_data=False):
         """ 获得指定表格的某个字段的统计特征ValuesStat2对象
 
         :param table_name: 表名
-        :param field_name: 用于计算统计数据的字段名
+        :param column: 用于计算统计数据的字段名
         :param percentile_count: 分位数的数量，例如 3 表示只计算中位数
         :param by_data: 是否获得原始数据
             默认只获得统计特征，不获得原始数据
         """
 
         def init_from_db_data():
-            sql = SQLBuilder(table_name)
+            sql = SqlBuilder(table_name)
             if filter_condition:
                 sql.where(filter_condition)
-            values = self.exec2col(sql.build_select(field_name))
+            values = self.exec2col(sql.build_select(column))
             if data_type == 'numeric':
                 values = [x and float(x) for x in values]
             return ValuesStat2(raw_values=values, data_type=data_type)
 
         def init_from_db():
             # 1 构建基础的 SQL 查询
-            sql = SQLBuilder(table_name)
+            sql = SqlBuilder(table_name)
             sql.select("COUNT(*) AS total_count")
-            sql.select(f"COUNT({field_name}) AS non_null_count")
-            sql.select(f"MIN({field_name}) AS min_value")
-            sql.select(f"MAX({field_name}) AS max_value")
-            if 'timestamp' in data_type:
+            sql.select(f"COUNT({column}) AS non_null_count")
+            sql.select(f"MIN({column}) AS min_value")
+            sql.select(f"MAX({column}) AS max_value")
+            if data_type and 'timestamp' in data_type:
                 percentile_type = 'PERCENTILE_DISC'
                 # todo 其实时间类也可以"泛化"一种平均值、标准差算法的，这需要获取全量数据，然后自己计算
             elif data_type == 'text':
                 percentile_type = 'PERCENTILE_DISC'
             else:  # 默认是正常的数值类型
-                sql.select(f"SUM({field_name}) AS total_sum")
-                sql.select(f"AVG({field_name}) AS average")
-                sql.select(f"STDDEV({field_name}) AS standard_deviation")
+                sql.select(f"SUM({column}) AS total_sum")
+                sql.select(f"AVG({column}) AS average")
+                sql.select(f"STDDEV({column}) AS standard_deviation")
                 percentile_type = 'PERCENTILE_CONT'
 
             percentiles = []
@@ -300,7 +306,7 @@ WHERE {table_name}.{item_id_name} = cte.{item_id_name}"""
                 step = 1 / (percentile_count - 1)
                 percentiles = [(i * step) for i in range(1, percentile_count - 1)]
                 for p in percentiles:
-                    sql.select(f"{percentile_type}({p:.2f}) WITHIN GROUP (ORDER BY {field_name}) "
+                    sql.select(f"{percentile_type}({p:.2f}) WITHIN GROUP (ORDER BY {column}) "
                                f"AS percentile_{int(p * 100)}")
 
             if filter_condition:
@@ -326,7 +332,7 @@ WHERE {table_name}.{item_id_name} = cte.{item_id_name}"""
 
             return x
 
-        data_type = self.get_column_data_type(table_name, field_name)
+        data_type = self.get_column_data_type(table_name, column)
         if by_data:
             vs = init_from_db_data()
         else:
@@ -334,6 +340,47 @@ WHERE {table_name}.{item_id_name} = cte.{item_id_name}"""
 
         return vs
 
+    def export_jsonl(self, file_path, table_name, key_col=None, batch_size=1000):
+        """ 将某个表导出为本地jsonl文件
+
+        :param table_name: 表名
+            支持传入SqlBuilder对象，这样可以更灵活的控制导出的数据规则
+        :param file_path: 导出的文件路径
+        :param batch_size: 每次读取的行数和保存的行数
+        :param key_col: 作为主键的列名，如果有的话，会自动去重
+            强烈推荐要设置
+            实际不一定要用主键，只要是有顺序值的列就行
+
+        todo 暴力最简单的版本不难写，我纠结的是缓存机制，还有bytes类型数据会有点大等问题
+            还需要先支持一个通用的缓存写文件功能
+        """
+        # 1 sql
+        if isinstance(table_name, str):
+            sql = SqlBuilder(table_name)
+            sql.select('*')
+        else:
+            sql = table_name
+            m = re.search(r'FROM (\w+)', sql.build_select())
+            table_name = m.group(1) if m else 'table'
+        assert isinstance(sql, SqlBuilder)
+
+        file_path = XlPath(file_path)
+        if key_col:
+            sql.order_by(key_col)
+            if file_path.is_file():
+                # 读取现有数据，找出主键最大值
+                data = file_path.read_jsonl(batch_size=1000)
+                max_val = max([x[key_col] for x in data]) if data else None
+                if max_val is not None:
+                    sql.where(f'{key_col} > {max_val}')
+
+        # 2 获取数据
+        file = StreamJsonlWriter(file_path, batch_size=batch_size)  # 流式存储
+        rows, total = self.exec2dict_batch(sql, batch_size=batch_size)
+        for row in tqdm(rows, total=total, desc=table_name):
+            file.append_line(row)
+        file.flush()
+
 
 """
 【关于为什么XlprDb要和pglib合一个文件】

{pyxllib-0.3.109 → pyxllib-0.3.111}/pyxllib/data/sqlite.py

@@ -19,7 +19,7 @@ warnings.filterwarnings('ignore', message="pandas only support SQLAlchemy connec
 warnings.filterwarnings('ignore', message="pandas only supports SQLAlchemy connectable")
 
 
-class SQLBuilder:
+class SqlBuilder:
     def __init__(self, table=''):
         self.table = table
         self._select = []
@@ -53,6 +53,25 @@ class SQLBuilder:
         self._where.append(condition)
         return self
 
+    def where_in(self, column, values):
+        if values is None:
+            return self
+
+        if isinstance(values, str):
+            values = [values]
+        values_str = ', '.join(f"'{str(value)}'" for value in values)
+        if len(values) == 1:
+            self._where.append(f"{column} = {values_str[0]}")
+        else:
+            self._where.append(f"{column} IN ({values_str})")
+        return self
+
+    def where_or(self, *conditions):
+        """ 输入的这一批条件，作为OR组合后成为一个整体条件
+        """
+        self._where.append(f"({' OR '.join(conditions)})")
+        return self
+
     def group_by(self, *columns):
         self._group_by.extend(columns)
         return self
@@ -106,7 +125,7 @@ class SQLBuilder:
         return '\n'.join(sql)
 
     def build_check_data_type(self, column):
-        sql = SQLBuilder('information_schema.columns')
+        sql = SqlBuilder('information_schema.columns')
         sql.select(f"data_type")
         sql.where(f"table_name='{self.table}' AND column_name='{column}'")
         return sql.build_select()
@@ -381,7 +400,7 @@ class SqlBase:
 
     def get_column_data_type(self, table_name, col_name):
         """ 获取表格中某一列的数据类型 """
-        return self.exec2one(SQLBuilder(table_name).build_check_data_type(col_name))
+        return self.exec2one(SqlBuilder(table_name).build_check_data_type(col_name))
 
 
 class Connection(sqlite3.Connection, SqlBase):

{pyxllib-0.3.109 → pyxllib-0.3.111}/pyxllib/ext/kq5034lib.py

@@ -28,7 +28,7 @@ import fire
 import pandas as pd
 from tqdm import tqdm
 import requests
-import requests_cache
+# import requests_cache
 
 from pyxllib.text.pupil import chinese2digits, grp_chinese_char
 from pyxllib.file.xlsxlib import openpyxl

{pyxllib-0.3.109 → pyxllib-0.3.111}/pyxllib/file/specialist/filelib.py

@@ -1184,30 +1184,46 @@ class XlPath(type(pathlib.Path())):
             json.dump(data, f, **kwargs)
 
     def read_jsonl(self, encoding='utf8', max_items=None, *,
-                   errors='strict', return_mode: bool = False):
+                   errors='strict', return_mode=0, batch_size=None):
         """ 从文件中读取JSONL格式的数据
 
         :param str encoding: 文件编码格式，默认为utf8
         :param str errors: 读取文件时的错误处理方式，默认为strict
         :param bool return_mode: 是否返回文件编码格式，默认为False
+            0, 读取全量数据返回
+            1，返回文件编码格式
         :param int max_items: 限制读取的条目数，默认为None，表示读取所有条目
+        :param int batch_size:
+            默认为None，表示一次性读取所有数据
+            如果设置了数值，则会流式读取，常用语太大，超过内存大小等的jsonl文件读取
+                注意如果设置了大小，只是底层每次一批读取的大小，但返回的data仍然是一维的数据格式迭代器
         :return: 返回读取到的数据列表，如果return_mode为True，则同时返回文件编码格式
 
         >> read_jsonl('data.jsonl', max_items=10)  # 读取前10条数据
         """
-        s, encoding = self.read_text(encoding=encoding, errors=errors, return_mode=True)
+        if batch_size is None:
+            s, encoding = self.read_text(encoding=encoding, errors=errors, return_mode=True)
+
+            data = []
+            # todo 这一步可能不够严谨，不同的操作系统文件格式不同。但使用splitlines也不太好，在数据含有NEL等特殊字符时会多换行。
+            for line in s.split('\n'):
+                if line:
+                    try:  # 注意，这里可能会有数据读取失败
+                        data.append(json.loads(line))
+                    except json.decoder.JSONDecodeError:
+                        pass
+                # 如果达到了限制的条目数，就停止读取
+                if max_items is not None and len(data) >= max_items:
+                    break
+        else:
+            def get_data():
+                for line in self.yield_line(batch_size, encoding=encoding):
+                    try:  # 注意，这里可能会有数据读取失败
+                        yield json.loads(line)
+                    except json.decoder.JSONDecodeError:
+                        pass
 
-        data = []
-        # todo 这一步可能不够严谨，不同的操作系统文件格式不同。但使用splitlines也不太好，在数据含有NEL等特殊字符时会多换行。
-        for line in s.split('\n'):
-            if line:
-                try:  # 注意，这里可能会有数据读取失败
-                    data.append(json.loads(line))
-                except json.decoder.JSONDecodeError:
-                    pass
-            # 如果达到了限制的条目数，就停止读取
-            if max_items is not None and len(data) >= max_items:
-                break
+            data = get_data()
 
         if return_mode:
             return data, encoding
@@ -1437,9 +1453,9 @@ class XlPath(type(pathlib.Path())):
         dst = XlPath(dst)
         if dst.exist_preprcs(if_exists):
             if self.is_file():
-                shutil.copy2(self, dst)
+                return shutil.copy2(self, dst)
             else:
-                shutil.copytree(self, dst)
+                return shutil.copytree(self, dst)
 
     def move(self, dst, if_exists=None):
         if not self.exists():
@@ -1777,7 +1793,7 @@ class XlPath(type(pathlib.Path())):
 
         return file_summary
 
-    def _check_dir_summary(self, print_mode=True, hash_func=None, run_mode=99):
+    def _check_dir_summary(self, print_mode=True, hash_func=None, run_mode=31):
         """ 对文件夹情况进行通用的状态检查
 
         :param hash_func: 可以传入自定义的hash函数，用于第四块的重复文件运算
@@ -1794,28 +1810,28 @@ class XlPath(type(pathlib.Path())):
 
         # 一 目录大小，二 各后缀文件大小
         msg = []
-        if run_mode >= 1:  # 1和2目前是绑定一起运行的
+        if run_mode & 1:  # 1和2目前是绑定一起运行的
             printf('【' + self.as_posix() + '】目录检查')
             printf('\n'.join(self.check_size('list')))
 
         # 三 重名文件
-        if run_mode >= 3:
+        if run_mode & 2:
             printf('\n三、重名文件（忽略大小写，跨目录检查name重复情况）')
             printf('\n'.join(self.check_repeat_name_files(print_mode=False)))
 
         # 四 重复文件
-        if run_mode >= 4:
+        if run_mode & 4:
             printf('\n四、重复文件（etag相同）')
             printf('\n'.join(self.check_repeat_files(print_mode=False, hash_func=hash_func)))
 
         # 五 错误扩展名
-        if run_mode >= 5:
+        if run_mode & 8:
             printf('\n五、错误扩展名')
             for i, (f1, suffix2) in enumerate(self.xglob_faker_suffix_files('**/*'), start=1):
                 printf(f'{i}、{f1.relpath(self)} -> {suffix2}')
 
         # 六 文件配对
-        if run_mode >= 6:
+        if run_mode & 16:
             printf(
                 '\n六、文件配对（检查每个目录里stem名称是否配对，列出文件组成不单一的目录结构，请重点检查落单未配对的情况）')
             prompt = False
@@ -2091,6 +2107,48 @@ class XlPath(type(pathlib.Path())):
         return file
 
 
+class StreamJsonlWriter:
+    """ 流式存储，主要用于存储文本化、jsonl格式数据 """
+
+    def __init__(self, file_path, batch_size=2000, *,
+                 delete_origin_file=False, json_default=str):
+        self.file_path = XlPath(file_path)
+        self.cache_text_lines = []
+        self.batch_size = batch_size
+        self.total_lines = 0
+
+        self.delete_origin_file = delete_origin_file
+        self.json_default = json_default
+
+    def append_line(self, line):
+        self.append_lines([line])
+
+    def append_lines(self, data):
+        """
+        :param list data: 添加一组数据
+        """
+        for x in data:
+            if isinstance(x, str):
+                self.cache_text_lines.append(x)
+            else:
+                self.cache_text_lines.append(json.dumps(x, ensure_ascii=False,
+                                                        default=self.json_default))
+        if len(self.cache_text_lines) >= self.batch_size:
+            self.flush()
+
+    def flush(self):
+        """ 刷新，将当前缓存写入文件 """
+        if self.cache_text_lines:
+            if self.total_lines == 0 and self.delete_origin_file:  # 第一次写入时，删除旧缓存文件
+                self.file_path.delete()
+
+            self.total_lines += len(self.cache_text_lines)
+            self.file_path.parent.mkdir(exist_ok=True, parents=True)
+            with open(self.file_path, 'a', encoding='utf8') as f:
+                f.write('\n'.join(self.cache_text_lines) + '\n')
+            self.cache_text_lines = []
+
+
 def demo_file():
     """ File类的综合测试"""
     temp = tempfile.gettempdir()

{pyxllib-0.3.109 → pyxllib-0.3.111}/pyxllib/prog/specialist/bc.py

@@ -16,7 +16,10 @@ from pyxllib.file.specialist import File, Dir, filesmatch, get_encoding, XlPath
 # BCompare.exe， bcompare函数要用
 
 class BCompare(Explorer):
-    def __init__(self, app='BCompare', shell=False):
+    def __init__(self, app='bcomp', shell=False):
+        """
+        240512周日20:06，本来写的是BCompare，但是友鑫mac电脑上发现似乎有问题，所以改成bcomp，这种在windows上也能用
+        """
         super().__init__(app, shell)
 
     @classmethod
@@ -48,7 +51,7 @@ class BCompare(Explorer):
         default_suffix = None
         for i, arg in enumerate(args):
             f = XlPath.safe_init(arg)
-            if f.is_file():  # 是文件对象，且存在
+            if f is not None and f.is_file():  # 是文件对象，且存在
                 new_args.append(f)
                 if not default_suffix:
                     default_suffix = f.suffix

{pyxllib-0.3.109 → pyxllib-0.3.111}/pyxllib/prog/specialist/browser.py

@@ -13,6 +13,7 @@ import subprocess
 import sys
 import datetime
 import platform
+import re
 
 import pandas as pd
 from bs4 import BeautifulSoup
@@ -118,9 +119,12 @@ class Explorer:
         TODO 获得返回值分析
         """
         args = [self.app] + list(args)
+
         if 'shell' not in kwargs:
             kwargs.update({'shell': self.shell})
-
+        if re.match(r'open\s', self.app):
+            args = args[0] + ' ' + args[1]
+            kwargs.update({'shell': True})
         try:
             if wait:
                 subprocess.run(args, **kwargs)
@@ -161,6 +165,7 @@ class Browser(Explorer):
                 # 这里默认设置为 'google-chrome'，如果你想使用其他的浏览器，例如Firefox，可以修改为 'firefox'
                 app = 'google-chrome'
             else:
+                app = 'open -a "Google Chrome"'
                 # 其他系统的处理
                 pass
         super().__init__(app, shell)
@@ -232,7 +237,8 @@ class Browser(Explorer):
         :param file: 默认可以不输入，会按七牛的etag哈希值生成临时文件
             如果输入，则按照指定的名称生成文件
         """
-        if XlPath.safe_init(arg).is_file():
+        f = XlPath.safe_init(arg)
+        if f is not None and f.is_file():
             file = arg
         else:
             file = str(self.to_brower_file(arg, file, clsmsg=clsmsg, to_html_args=to_html_args))

{pyxllib-0.3.109 → pyxllib-0.3.111/pyxllib.egg-info}/PKG-INFO

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

{pyxllib-0.3.109 → pyxllib-0.3.111}/setup.py

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