pyxllib 0.3.96__py3-none-any.whl → 0.3.197__py3-none-any.whl

pyxllib/algo/geo.py

@@ -33,6 +33,18 @@ def ltrb2xywh(p):
     return [p[0], p[1], p[2] - p[0], p[3] - p[1]]
 
 
+def ltrb2polygon(p):
+    """ ltrb坐标转多边形
+
+    :param list|tuple p: [left, top, right, bottom]
+    :rtype: list
+
+    >>> ltrb2polygon([100, 50, 200, 150])
+    [[100, 50], [200, 50], [200, 150], [100, 150]]
+    """
+    return [p[:2], [p[2], p[1]], p[2:], [p[0], p[3]]]
+
+
 def rect2polygon(src_pts):
     """ 矩形对角线两个点，转成四边形四个点的模式来表达
     （输入左上、右下两个顶点坐标）

pyxllib/algo/intervals.py

@@ -883,7 +883,7 @@ class StrIdxBack:
         self.keystr = s
 
     def delchars(self, pattern, flags=0):
-        """模仿正则的替换语法
+        r""" 模仿正则的替换语法
         但是不用输入替换目标s，以及目标格式，因为都是删除操作
 
         利用正则可以知道被删除的是哪个区间范围

pyxllib/algo/matcher.py

@@ -13,6 +13,8 @@ from pyxllib.prog.pupil import check_install_package
 # check_install_package('Levenshtein', 'python-Levenshtein')
 
 from collections import defaultdict
+import heapq
+import math
 import warnings
 
 warnings.filterwarnings("ignore", message="loaded more than 1 DLL from .libs:")
@@ -40,6 +42,53 @@ except ModuleNotFoundError:
     pass
 
 
+def calculate_coeff_favoring_length(length1, length2, baseline=100, scale=10000):
+    """
+    根据两文本的长度计算相似度调整系数，以解决短文本过高相似度评分的问题。
+
+    短文本之间相似或完全相同的片段可能导致相似度评分过高，从而误判文本间的相关性比实际更高。
+    通过引入相似度调整系数来平衡评分，降低短文本之间的相似度得分，使评分更加合理和公平。
+
+    :param length1: 第一文本的长度
+    :param length2: 第二文本的长度
+    :param baseline: 基线长度，影响系数调整的起始点。
+    :param scale: 尺度长度，定义了系数增长到2的长度标准。
+    :return: 相似度调整系数。
+    """
+    total_length = length1 + length2
+    length_ratio = min(length1, length2) / max(length1, length2)
+
+    if total_length < baseline:
+        coefficient = 0.5 + 0.5 * (total_length / baseline)
+    else:
+        coefficient = 1 + (math.log1p(total_length - baseline + 1) / math.log1p(scale - baseline + 1))
+
+    # 考虑长度差异的影响
+    coefficient *= length_ratio
+
+    return coefficient
+
+
+def compute_text_similarity_favoring_length(text1, text2, baseline=100, scale=10000):
+    """
+    计算两段文本之间的相似度，引入长度调整系数以解决短文本过高相似度评分的问题。
+
+    :param text1: 第一段文本
+    :param text2: 第二段文本
+    :param baseline: 基线长度，影响系数调整的起始点。
+    :param scale: 尺度长度，定义了系数增长到2的长度标准。
+    :return: 加权后的相似度得分，范围在0到1之间。
+    """
+    base_similarity = Levenshtein.ratio(text1, text2)
+    coefficient = calculate_coeff_favoring_length(len(text1), len(text2), baseline, scale)
+
+    # 计算加权相似度
+    weighted_similarity = base_similarity * coefficient
+
+    # 确保相似度不会超过1
+    return min(weighted_similarity, 1.0)
+
+
 class DataMatcher:
     """ 泛化的匹配类，对任何类型的数据进行匹配 """
 
@@ -161,6 +210,35 @@ class DataMatcher:
         center_idx = max(indices, key=lambda x: sum(get_similarity(x, y) for y in indices))
         return center_idx
 
+    def find_top_similar_pairs(self, top_n=1):
+        """找到最相近的top_n对数据。
+
+        :param top_n: 需要返回的最相似的数据对的数量。
+        :return: 一个列表，包含(top_n个)最相似数据对的索引和它们之间的相似度。
+        """
+        if len(self.data) < 2:
+            return []
+
+        # 初始化一个列表来保存最相似的数据对，使用最小堆来维护这个列表
+        # 最小堆能够保证每次都能快速弹出相似度最小的数据对
+        top_pairs = []
+
+        for i in tqdm(range(len(self.data))):
+            for j in range(i + 1, len(self.data)):
+                similarity = self.compute_similarity(self.data[i], self.data[j])
+
+                # 如果当前相似度对数量还未达到top_n，直接添加
+                if len(top_pairs) < top_n:
+                    heapq.heappush(top_pairs, (similarity, (i, j)))
+                else:
+                    # 如果当前对的相似度大于堆中最小的相似度，替换之
+                    if similarity > top_pairs[0][0]:
+                        heapq.heapreplace(top_pairs, (similarity, (i, j)))
+
+        # 将堆转换为排序后的列表返回
+        top_pairs.sort(reverse=True, key=lambda x: x[0])
+        return [(pair[1], pair[0]) for pair in top_pairs]
+
 
 class GroupedDataMatcher(DataMatcher):
     """ 对数据量特别大的情况，我们可以先对数据进行分组，然后再对每个分组进行匹配 """

pyxllib/algo/pupil.py

@@ -4,11 +4,13 @@
 # @Email  : 877362867@qq.com
 # @Date   : 2021/06/03 14:22
 
-import textwrap
+from bisect import bisect_right
 from collections import defaultdict, Counter
-import math
+import datetime
 import re
+from statistics import quantiles
 import sys
+import textwrap
 
 from pyxllib.prog.newbie import typename, human_readable_number
 from pyxllib.text.pupil import listalign, int2myalphaenum
@@ -152,6 +154,189 @@ class ValuesStat:
             raise ValueError("无效的数据数量")
 
 
+class ValuesStat2:
+    """ 240509周四17:33，第2代统计器
+
+    240628周五14:05 todo 关于各种特殊格式数据，怎么计算是个问题
+        这问题可能有些复杂，近期估计没空折腾，留以后有空折腾的一个大坑了
+    """
+
+    def __init__(self, values=None, raw_values=None, data_type=None):
+        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')]
+            else:
+                values = [x for x in raw_values if isinstance(x, (int, float))]  # todo 可能需要更泛用的判断数值的方法
+
+        self.date_type = data_type
+        self.raw_values = raw_values
+        values = values or []
+        self.values = sorted(values)
+        if self.raw_values:
+            self.raw_n = len(self.raw_values)
+        else:
+            self.raw_n = 0
+        self.n = len(values)
+
+        if 'timestamp' in data_type:
+            self.sum = None
+        else:
+            self.sum = sum(values)
+
+        if self.n:
+            self.mean = mean(self.values)
+            self.std = pstdev(self.values)
+            self.min, self.max = self.values[0], self.values[-1]
+        else:
+            self.mean = self.std = self.min = self.max = None
+
+        self.dist = None
+
+    def __len__(self):
+        return self.n
+
+    def _summary(self, unit=None, precision=4, percentile_count=5):
+        """ 返回字典结构的总结 """
+        """ 文本汇总性的报告
+
+        :param percentile_count: 包括两个极值端点的切分点数，
+            设置2，就是不设置分位数，就是只展示最小、最大值
+            如果设置了3，就表示"中位数、二分位数"，在展示的时候，会显示50%位置的分位数值
+            如果设置了5，就相当于"四分位数"，会显示25%、50%、75%位置的分位数值
+        :param unit: 展示数值时使用的单位
+        :param precision: 展示数值时的精度
+        """
+
+        # 1 各种细分的格式化方法
+        def fmt0(v):
+            # 数量类整数的格式
+            return human_readable_number(v, '万')
+
+        def fmt1(v):
+            if isinstance(v, str):
+                return v
+            return human_readable_number(v, unit or 'K', precision)
+
+        def fmt2(v):
+            # 日期类数据的格式化
+            # todo 这个应该数据的具体格式来设置的，但是这个现在有点难写，先写死
+            if isinstance(v, str):
+                return v
+            elif isinstance(v, (int, float)):
+                v = datetime.datetime.fromtimestamp(v)
+
+            return v.strftime(unit or '%Y-%m-%d %H:%M:%S')
+
+        def fmt2b(v):
+            # 时间长度类数据的格式化
+            return human_readable_number(v, '秒')
+
+        if 'timestamp' in self.date_type:
+            fmt = fmt2
+            fmtb = fmt2b
+        else:
+            fmt = fmtb = fmt1
+
+        # 2 生成统计报告
+        desc = {}
+        if self.raw_n and 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)}"
+
+        if self.sum is not None:
+            desc["总和"] = f"{fmt(self.sum)}"
+        if self.mean is not None and self.std is not None:
+            desc["均值±标准差"] = f"{fmt(self.mean)}±{fmtb(self.std)}"
+        elif self.mean is not None:
+            desc["均值"] = f"{fmt(self.mean)}"
+        elif self.std is not None:
+            desc["标准差"] = f"{fmtb(self.std)}"
+
+        if self.values:
+            dist = [self.values[0]]
+            if percentile_count > 2:
+                quartiles = quantiles(self.values, n=percentile_count - 1)
+                dist += quartiles
+            dist.append(self.values[-1])
+
+            desc["分布"] = '/'.join([fmt(v) for v in dist])
+        elif self.dist:
+            desc["分布"] = '/'.join([fmt(v) for v in self.dist])
+
+        return desc
+
+    def summary(self, unit=None, precision=4, percentile_count=5):
+        """ 文本汇总性的报告
+
+        :param unit: 展示数值时使用的单位
+        :param precision: 展示数值时的精度
+        :param percentile_count: 包括两个极值端点的切分点数，
+            设置2，就是不设置分位数，就是只展示最小、最大值
+            如果设置了3，就表示"中位数、二分位数"，在展示的时候，会显示50%位置的分位数值
+            如果设置了5，就相当于"四分位数"，会显示25%、50%、75%位置的分位数值
+        """
+        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, unit=False):
+        """ 计算并返回一个字典，其中包含每个 x_values 中的值与其小于等于该值的元素的比例
+
+        :param x_values: 一个数值列表，用来计算每个数值小于等于它的元素的比例
+        :param fmt: 直接将值格式化好
+        :return: 一个字典，键为输入的数值，值为对应的比例（百分比）
+        """
+        ratio_dict = {}
+        for x in x_values:
+            position = bisect_right(self.values, x)
+            if self.n > 0:
+                ratio = (position / self.n)
+            else:
+                ratio = 0
+            ratio_dict[x] = ratio
+
+        def unit_func(x):
+            if unit:
+                return human_readable_number(x, unit, 4)
+            return x
+
+        if fmt:
+            ratio_dict = {unit_func(x): f'{ratio:.2%}' for x, ratio in ratio_dict.items()}
+
+        return ratio_dict
+
+    def group_count(self, max_entries=None, min_count=None):
+        """ 统计每种取值出现的次数，并根据条件过滤结果
+
+        :param max_entries: 最多显示的条目数
+        :param min_count: 显示的条目至少出现的次数
+        """
+        from collections import Counter
+
+        # 使用Counter来计数每个值出现的次数
+        counts = Counter(self.values or self.raw_values)
+
+        # 根据min_count过滤计数结果
+        if min_count is not None:
+            counts = {k: v for k, v in counts.items() if v >= min_count}
+
+        # 根据max_entries限制结果数量
+        if max_entries is not None:
+            # 按出现次数降序排列，然后选取前max_entries项
+            most_common = counts.most_common(max_entries)
+            # 转换回字典形式
+            counts = dict(most_common)
+        else:
+            # 如果没有指定max_entries，则保持所有满足min_count的结果
+            counts = dict(sorted(counts.items(), key=lambda item: item[1], reverse=True))
+
+        return counts
+
+
 class Groups:
     def __init__(self, data):
         """ 分组
@@ -296,23 +481,6 @@ def matchpairs(xs, ys, cmp_func, least_score=sys.float_info.epsilon, *,
     return pairs
 
 
-def get_number_width(n):
-    """ 判断数值n的长度
-
-    >>> get_number_width(0)
-    Traceback (most recent call last):
-    AssertionError
-    >>> get_number_width(9)
-    1
-    >>> get_number_width(10)
-    2
-    >>> get_number_width(97)
-    2
-    """
-    assert n > 0
-    return math.ceil(math.log10(n + 1))
-
-
 class SearchBase:
     """ 一个dfs、bfs模板类 """
 

pyxllib/algo/specialist.py

@@ -11,7 +11,8 @@ import numpy as np
 import pandas as pd
 
 from pyxllib.prog.pupil import DictTool
-from pyxllib.prog.deprecatedlib import deprecated
+# from pyxllib.prog.deprecatedlib import deprecated
+from deprecated import deprecated
 
 
 @deprecated(reason='这个实现方式不佳，请参考 make_index_function')

pyxllib/algo/stat.py

@@ -18,6 +18,10 @@ from pyxllib.prog.pupil import dprint, typename
 from pyxllib.file.specialist import XlPath
 
 pd.options.display.unicode.east_asian_width = True  # 优化中文输出对齐问题
+try:
+    pd.set_option('future.no_silent_downcasting', True)
+except Exception as e:
+    pass
 
 
 def treetable(childreds, parents, arg3=None, nodename_colname=None):
@@ -250,13 +254,18 @@ def xlpivot(df, index=None, columns=None, values=None):
     :param columns: 列划分方式
     :param values: 显示的值
         Callable[items, value]：输出一个函数
+        list[str]: 支持输入属性列表，表示显示原始值的意思。如果原始值不唯一，则逗号分开拼接后显示。但这种用法就不太算是传统意义的数据透视表了
     :return: 数据透视表的表格
 
     使用示例：
     def func(items):  # 输入匹配的多行数据
         x = items.iloc[0]
         return f'{x["precision"]:.0f}，{x["recall"]:.0f}，{x["hmean"]:.2f}，{x["fps"]}'  # 返回显示的值
-    >> df2 = xlpivot(df, ['model_type'], ['dataset', 'total_frame'], {'precision，recall，hmean，fps': func})
+
+    >> df2 = xlpivot(df, ['model_type'], ['dataset', 'total_frame'],
+                        {'precision，recall，hmean，fps': func})
+
+    注意技巧：如果要在分组后约束特定顺序，可以使用特殊前缀进行编号对齐
     """
 
     # 1 将分组的格式标准化
@@ -271,6 +280,17 @@ def xlpivot(df, index=None, columns=None, values=None):
     index_, columns_ = reset_groups(index), reset_groups(columns)
 
     # 2 目标值的格式标准化
+    def make_col_func(col):
+        def func(rows):
+            if len(rows):
+                return ', '.join(map(str, rows[col].values))
+            return ''
+
+        return func
+
+    if isinstance(values, (list, tuple)):
+        values = {v: make_col_func(v) for v in values}
+
     if callable(values):
         values_ = {'values': values}
     elif isinstance(values, dict):
@@ -279,6 +299,8 @@ def xlpivot(df, index=None, columns=None, values=None):
         raise TypeError
 
     # 3 分组
+    assert len(df), 'df是空的'
+
     keys = index_ + columns_
     dfgp = df.groupby(keys)
     data = defaultdict(list)
@@ -429,7 +451,7 @@ def print_full_dataframe(df):
                            'display.max_colwidth', None):
         print(df)
 
-    pd.options('display.max_rows', 60)
+    pd.options.display.max_rows = 60
 
 
 def custom_fillna(df, default_fill_value='', numeric_fill_value=None, specific_fill=None):
@@ -456,3 +478,17 @@ def custom_fillna(df, default_fill_value='', numeric_fill_value=None, specific_f
             df[column] = df[column].fillna(default_fill_value)
         # 可以在这里添加更多条件，以处理其他数据类型，如datetime。
     return df
+
+
+def dataframe_to_list(df):
+    """将DataFrame转换为列表结构，第一行是表头，其余是数据"""
+    # 获取表头（列名）作为第一个列表元素
+    headers = df.columns.tolist()
+
+    # 获取数据行，每一行作为一个列表，然后将所有这些列表收集到一个大列表中
+    data_rows = df.values.tolist()
+
+    # 将表头和数据行合并成最终的列表
+    result_list = [headers] + data_rows
+
+    return result_list

{pyxlpr → pyxllib/autogui}/__init__.py

@@ -2,4 +2,4 @@
 # -*- coding: utf-8 -*-
 # @Author : 陈坤泽
 # @Email  : 877362867@qq.com
-# @Date   : 2020/11/26
+# @Date   : 2021/08/01 15:26