pyxllib 0.3.95__tar.gz → 0.3.100__tar.gz

{pyxllib-0.3.95/pyxllib.egg-info → pyxllib-0.3.100}/PKG-INFO

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

{pyxllib-0.3.95 → pyxllib-0.3.100}/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-0.3.95 → pyxllib-0.3.100}/pyxllib/algo/stat.py

@@ -430,3 +430,43 @@ def print_full_dataframe(df):
         print(df)
 
     pd.options('display.max_rows', 60)
+
+
+def custom_fillna(df, default_fill_value='', numeric_fill_value=None, specific_fill=None):
+    """ 使用更多灵活性填充DataFrame中的NaN值。
+
+    :param pandas.DataFrame df: 需要处理的DataFrame。
+    :param str default_fill_value: 非数值列中NaN的默认填充值。
+    :param numeric_fill_value: 数值列中NaN的填充值，如果不指定，则默认为None。
+    :param dict specific_fill: 指定列名及其NaN的填充值，如果不指定，则默认为None。
+    :return: 已根据指定标准填充NaN值的pandas.DataFrame。
+
+    >>> df = pd.DataFrame({'A': [1, 2, None], 'B': [None, 'x', 'y'], 'C': [None, None, None]})
+    >>> custom_fillna(df, 'filled', 0, {'C': 'special'})
+    """
+    for column in df.columns:
+        # 检查列是否在specific_fill中指定；如果是，则使用指定的值填充。
+        if specific_fill and column in specific_fill:
+            df[column] = df[column].fillna(specific_fill[column])
+        # 如果列是数值型且指定了numeric_fill_value，则使用numeric_fill_value填充。
+        elif numeric_fill_value is not None and pd.api.types.is_numeric_dtype(df[column]):
+            df[column] = df[column].fillna(numeric_fill_value)
+        # 否则，对非数值列使用default_fill_value进行填充。
+        elif pd.api.types.is_object_dtype(df[column]) or pd.api.types.is_string_dtype(df[column]):
+            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

{pyxllib-0.3.95 → pyxllib-0.3.100}/pyxllib/data/echarts.py

@@ -14,10 +14,14 @@ from pyxllib.prog.pupil import check_install_package
 
 check_install_package('pyecharts')
 
+# import types
+
 import pyecharts
 from pyecharts import options as opts
 from pyecharts.commons.utils import JsCode
-from pyecharts.charts import Bar, Line
+from pyecharts.globals import ChartType
+from pyecharts import types
+from pyecharts.charts import Bar, Line, Radar
 from pyecharts.charts.chart import Chart
 
 from pyxllib.prog.pupil import inject_members
@@ -54,7 +58,7 @@ class XlChart(Chart):
                 kwargs['label']['formatter'] = fmt
 
         self._append_color(color)
-        self._append_legend(name)
+        self._append_legend(name, is_selected=True)
 
         self.options.get('series').append(
             {
@@ -100,6 +104,68 @@ class XlBar(Bar):
         """
         return cls.from_dict({'value': list(yaxis)}, xaxis=xaxis, title=title)
 
+    @classmethod
+    def from_data_split_into_groups(cls, data, groups, *, title=None):
+        """根据给定的组数自动拆分数据并生成条形图
+        :param list data: 数据清单
+        :param int groups: 要拆分成的组数
+        """
+        # 找到最大值和最小值
+        min_val, max_val = min(data), max(data)
+
+        # 计算间隔
+        interval = (max_val - min_val) / groups
+
+        # 分组和标签
+        group_counts = [0] * groups
+        labels = []
+        # todo 如果数据量特别大，这里应该排序后，再用特殊方法计算分组
+        for value in data:
+            index = min(int((value - min_val) / interval), groups - 1)
+            group_counts[index] += 1
+
+        for i in range(groups):
+            labels.append(f"{min_val + interval * i:.2f}-{min_val + interval * (i + 1):.2f}")
+        # t = cls.from_dict({'value': group_counts}, xaxis=labels, title=title)
+        
+        return cls.from_dict({'value': group_counts}, xaxis=labels, title=title)
+
+
+class XlRadar(Radar):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.color_idx = 0
+
+    def add(
+            self,
+            series_name: str,
+            data: types.Sequence[types.Union[opts.RadarItem, dict]],
+            *,
+            label_opts=None,
+            color: types.Optional[str] = None,
+            linestyle_opts=None,
+            **kwargs
+    ):
+        """ 标准库(2.0.5版)的雷达图颜色渲染有问题，这里要增加一个修正过程 """
+        if label_opts is None:
+            label_opts = opts.LabelOpts(is_show=False)
+
+        if linestyle_opts is None:
+            linestyle_opts = opts.LineStyleOpts(color=self.colors[self.color_idx % len(self.colors)])
+            self.color_idx += 1
+        elif linestyle_opts.get('color') is None:
+            linestyle_opts.update(color=self.colors[self.color_idx % len(self.colors)])
+            self.color_idx += 1
+
+        if color is None:
+            color = linestyle_opts.get('color')
+
+        return super(XlRadar, self).add(series_name, data,
+                                        label_opts=label_opts,
+                                        color=color,
+                                        linestyle_opts=linestyle_opts,
+                                        **kwargs)
+
 
 inject_members(XlBar, Bar)
 
@@ -117,7 +183,7 @@ def draw_pareto_chart(data, accuracy=0.1, *, title='帕累托累积权重', valu
     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}'))),
+        xaxis_opts=opts.AxisOpts(name='条目数', max_=int(float(f'{pts[-1][0] * 1.2:.2g}'))),
         yaxis_opts=opts.AxisOpts(name='累积和')
     )
     return x

{pyxllib-0.3.95 → pyxllib-0.3.100}/pyxllib/data/pglib.py

@@ -52,6 +52,17 @@ class Connection(psycopg.Connection, SqlBase):
     def __1_库(self):
         pass
 
+    def get_db_activities(self):
+        """
+        检索当前数据库的活动信息。
+        """
+        sql = """
+        SELECT pid, datname, usename, state, query, age(now(), query_start) AS "query_age"
+        FROM pg_stat_activity
+        WHERE state = 'active'
+        """
+        return self.exec2dict(sql).fetchall()
+
     def __2_表格(self):
         pass
 
@@ -140,6 +151,10 @@ class Connection(psycopg.Connection, SqlBase):
                 也可以写复杂的处理算法规则，详见 http://postgres.cn/docs/12/sql-insert.html
                 比如这里是插入的id重复的话，就把host_name替换掉，还可以指定nick_name替换为'abc'
                 注意前面的(id)是必须要输入的
+
+        注意：有个常见需求，是想插入后返回对应的id，但是这样就需要知道这张表自增的id字段名
+            以及还是很难获得插入后的id值，可以默认刚插入的id是最大的，但是这样并不安全，有风险
+            建议还是外部自己先计算全表最大的id值，自己实现自增，就能知道插入的这条数据的id了
         """
         ks = ','.join(cols.keys())
         vs = ','.join(['%s'] * (len(cols.keys())))
@@ -419,8 +434,8 @@ class XlprDb(Connection):
                 if gpu:
                     status['gpu_memory'] = ssh.check_gpu_usage(print_mode=True)
                 if disk:
-                    # 检查磁盘空间会很慢，如果超时可以跳过。
-                    status['disk_memory'] = ssh.check_disk_usage(print_mode=True, timeout=7200)
+                    # 检查磁盘空间会很慢，如果超时可以跳过。（设置超时6小时）
+                    status['disk_memory'] = ssh.check_disk_usage(print_mode=True, timeout=60 * 60 * 6)
             except Exception as e:
                 status = {'error': f'{str(type(e))[8:-2]}: {e}'}
                 print(status)
@@ -524,7 +539,8 @@ class XlprDb(Connection):
 
         args = ['CPU核心数（比如4核显示是400%）', date_trunc, recent, 'sum(hosts.cpu_number)*100']
 
-        htmltexts = ['<a target="_blank" href="https://www.yuque.com/xlpr/data/hnpb2g?singleDoc#"> 《服务器监控》工具使用文档 </a>']
+        htmltexts = [
+            '<a target="_blank" href="https://www.yuque.com/xlpr/data/hnpb2g?singleDoc#"> 《服务器监控》工具使用文档 </a>']
         res = self._get_host_trace_total('cpu', 'XLPR服务器 CPU 使用近况', *args)
         htmltexts.append(res[0])
 
@@ -546,7 +562,8 @@ class XlprDb(Connection):
 
         args = ['内存（单位：GB）', date_trunc, recent, 'sum(hosts.cpu_gb)']
 
-        htmltexts = ['<a target="_blank" href="https://www.yuque.com/xlpr/data/hnpb2g?singleDoc#"> 《服务器监控》工具使用文档 </a>']
+        htmltexts = [
+            '<a target="_blank" href="https://www.yuque.com/xlpr/data/hnpb2g?singleDoc#"> 《服务器监控》工具使用文档 </a>']
         res = self._get_host_trace_total('cpu_memory', 'XLPR服务器 内存 使用近况', *args)
         htmltexts.append(res[0])
 
@@ -570,7 +587,8 @@ class XlprDb(Connection):
 
         args = ['硬盘（单位：GB）', date_trunc, recent, 'sum(hosts.disk_gb)']
 
-        htmltexts = ['<a target="_blank" href="https://www.yuque.com/xlpr/data/hnpb2g?singleDoc#"> 《服务器监控》工具使用文档 </a>']
+        htmltexts = [
+            '<a target="_blank" href="https://www.yuque.com/xlpr/data/hnpb2g?singleDoc#"> 《服务器监控》工具使用文档 </a>']
         res = self._get_host_trace_total('disk_memory', 'XLPR服务器 DISK硬盘 使用近况', *args)
         htmltexts.append(res[0])
         htmltexts.append('注：xlpr4（四卡）服务器使用du计算/home大小有问题，未统计在列<br/>')
@@ -597,7 +615,8 @@ class XlprDb(Connection):
 
         args = ['显存（单位：GB）', date_trunc, recent, 'sum(hosts.gpu_gb)']
 
-        htmltexts = ['<a target="_blank" href="https://www.yuque.com/xlpr/data/hnpb2g?singleDoc#"> 《服务器监控》工具使用文档 </a>']
+        htmltexts = [
+            '<a target="_blank" href="https://www.yuque.com/xlpr/data/hnpb2g?singleDoc#"> 《服务器监控》工具使用文档 </a>']
         res = self._get_host_trace_total('gpu_memory', 'XLPR八台服务器 GPU显存 使用近况', *args)
         htmltexts.append(res[0])
 
@@ -641,3 +660,53 @@ class XlprDb(Connection):
                 self.update_row('files', {'dhash': computed_dhash}, {'id': file_id})
                 progress_bar.update(1)
             self.commit()
+
+    def append_history(self, table_name, where, backup_keys, *,
+                       can_merge=None,
+                       update_time=None,
+                       commit=False):
+        """ 为表格添加历史记录，请确保这个表有一个jsonb格式的historys字段
+
+        这里每次都会对关键字段进行全量备份，没有进行高级的优化。
+        所以只适用于一些历史记录功能场景。更复杂的还是需要另外自己定制。
+
+        :param table_name: 表名
+        :param where: 要记录的id的规则，请确保筛选后记录是唯一的
+        :param backup_keys: 需要备份的字段名
+        :param can_merge: 在某些情况下，history不需要非常冗余地记录，可以给定与上一条合并的规则
+            def can_merge(last, now):
+                "last是上一条字典记录，now是当前要记录的字典数据，
+                返回True，则用now替换last，并不新增记录"
+                ...
+
+        :param update_time: 更新时间，如果不指定则使用当前时间
+        """
+        # 1 获得历史记录
+        ops = ' AND '.join([f'{k}=%s' for k in where.keys()])
+        historys = self.exec2one(f'SELECT historys FROM {table_name} WHERE {ops}', list(where.values())) or []
+        if historys:
+            status1 = historys[-1]
+        else:
+            status1 = {}
+
+        # 2 获得新记录
+        if update_time is None:
+            update_time = utc_timestamp()
+        status2 = self.exec2dict(f'SELECT {",".join(backup_keys)} FROM {table_name} WHERE {ops}',
+                                 list(where.values())).fetchone()
+        status2['update_time'] = update_time
+
+        # 3 添加历史记录
+        if can_merge is None:
+            def can_merge(status1, status2):
+                for k in backup_keys:
+                    if status1.get(k) != status2.get(k):
+                        return False
+                return True
+
+        if historys and can_merge(status1, status2):
+            historys[-1] = status2
+        else:
+            historys.append(status2)
+
+        self.update_row(table_name, {'historys': historys}, where, commit=commit)

{pyxllib-0.3.95 → pyxllib-0.3.100}/pyxllib/data/sqlite.py

@@ -7,9 +7,12 @@
 import json
 import re
 import sqlite3
+import warnings
 
 import pandas as pd
 
+warnings.filterwarnings('ignore', message="pandas only support SQLAlchemy connectable")
+
 
 class SqlBase:
     """ Sql语法通用的功能 """
@@ -109,7 +112,10 @@ class SqlBase:
 
     def exec2one(self, *args, **kwargs):
         """ 获得第1行的值 """
-        return self.execute(*args, **kwargs).fetchone()[0]
+        try:
+            return self.execute(*args, **kwargs).fetchone()[0]
+        except TypeError:
+            return None
 
     def exec2row(self, *args, **kwargs):
         """ 获得第1行的值 """

{pyxllib-0.3.95 → pyxllib-0.3.100}/pyxllib/ext/kq5034lib.py

@@ -15,13 +15,14 @@ from pyxllib.prog.pupil import check_install_package
 check_install_package('fire')  # 自动安装依赖包
 
 from collections import Counter, defaultdict
-from datetime import date
+from datetime import date, timedelta
 import datetime
 import math
 import os
 import re
 import time
 from io import StringIO
+import csv
 
 import fire
 import pandas as pd
@@ -50,7 +51,7 @@ class Xiaoetong:
         self.token = ''
 
     def login(self, app_id, client_id, secret_key):
-        """ 登录
+        """ 登录，获取token
         """
         self.app_id = app_id
         self.client_id = client_id
@@ -78,6 +79,8 @@ class Xiaoetong:
             raise Exception("HTTP request failed with status code {}".format(response.status_code))
 
     def get_alive_user_list(self, resource_id, page_size=100):
+        """ 获取直播间用户
+        """
         # 1 获取总页数
         url = "https://api.xiaoe-tech.com/xe.alive.user.list/1.0.0"  # 接口地址【路径：API列表 -> 直播管理 -> 获取直播间用户列表】
         data_1 = {
@@ -106,6 +109,36 @@ class Xiaoetong:
             # lst.extend(data_1)
         return lst
 
+    def get_elock_actor(self, activity_id, page_size=100):
+        """ 获取打卡参与用户
+        """
+        # 获取总页数
+        url = "https://api.xiaoe-tech.com/xe.elock.actor/1.0.0"  # 接口地址【路径：API列表 -> 打卡管理 -> 获取打卡参与用户】
+        data_1 = {
+            "access_token": self.token,
+            "activity_id": activity_id,
+            "page_index": 1,
+            "page_size": page_size
+        }
+        response_1 = requests.post(url, data=data_1)
+        result_1 = response_1.json()
+        page = math.ceil(result_1['data']['count'] / page_size)  # 页数
+        # 获取打卡用户数据
+        lst = result_1['data']['list']
+        for i in range(1, page):  # 为什么从1开始，因为第一页的数据上面已经获取到了，这里没必要从新获取一次
+            data = {
+                "access_token": self.token,
+                "activity_id": activity_id,
+                "page_index": i + 1,
+                "page_size": page_size
+            }
+            response = requests.post(url, data=data)
+            result = response.json()
+            data_1 = result['data']['list']
+            lst += data_1
+            # lst.extend(data_1)
+        return lst
+
 
 class 网课考勤:
     def __init__(self, today=None):
@@ -652,6 +685,12 @@ class 网课考勤:
             except UnicodeDecodeError:
                 pass
 
+        if df is None:
+            try:
+                df = pd.read_csv(files[-1], encoding="ANSI")  # 240226周一11:21，
+            except UnicodeDecodeError:
+                pass
+
         if df is None:
             raise ValueError
 
@@ -921,6 +960,120 @@ class 网课考勤:
         # driver.click('//*[@id="commitRefundApplyBtn"]')  # 建议手动点"提交申请"
 
 
+class 网课考勤2(网课考勤):
+    def login_xe(self):
+        self.xe = Xiaoetong()  # 实例化
+        self.xe.login(self.app_id,
+                      self.client_id,
+                      self.secret_key)  # 获取了token
+
+    # 依据课程链接，获取资源id（与课次）
+    def 获取课次与资源id(self):
+        课程链接 = self.课程链接[1:]
+        ls_resource_id = [""]
+        for item in 课程链接:  # 课次
+            resource_id = re.search(r"detail\?id=(.+?)\&", item)  # 资源id
+            ls_resource_id.append(resource_id.group(1))
+        return ls_resource_id
+
+    # 获取直播间用户数据
+    def 获取直播间用户数据(self, resource_id, path):
+        if path.is_file():
+            return
+            # 2）获取直播间用户数据：
+        lst = self.xe.get_alive_user_list(resource_id)
+        fieldnames = ['用户ID', '用户昵称', '备注名', '状态', '直播间停留时长(秒)', '直播间停留时长',
+                      '累计观看时长(秒)', '累计观看时长', '直播观看时长(秒)', '直播观看时长', '回放观看时长(秒)',
+                      '回放观看时长', '评论次数', '直播间成交金额']
+        p = path
+        with open(p, mode='w', newline='', encoding='utf-8') as file:
+            writer = csv.DictWriter(file, fieldnames=fieldnames)
+            writer.writeheader()
+            for x in lst:
+                record = {
+                    '用户ID': x['user_id'],
+                    '用户昵称': x['wx_nickname'],
+                    '备注名': None,
+                    '状态': "其它关联权益",
+                    '直播间停留时长(秒)': x['his_online_time'],
+                    '直播间停留时长': str(timedelta(seconds=x['his_online_time'])),
+                    '累计观看时长(秒)': x['his_learn_time'],
+                    '累计观看时长': str(timedelta(seconds=x['his_learn_time'])),
+                    '直播观看时长(秒)': x['his_learning_time'],
+                    '直播观看时长': str(timedelta(seconds=x['his_learning_time'])),
+                    '回放观看时长(秒)': x['his_learned_time'],
+                    '回放观看时长': str(timedelta(seconds=x['his_learned_time'])),
+                    '评论次数': x['comment_num'],
+                    '直播间成交金额': x['user_total_price']
+                }
+                writer.writerow(record)
+
+    def 获取课次列表(self):
+        return list(range(max(self.结束课次2, 1), self.当天课次2 + 1))
+
+    def 下载课程(self):
+        prfx = self.prfx
+        lt = self.获取课次与资源id()
+        for i in tqdm(self.获取课次列表()):
+            resource_id = lt[i]
+            formatted_date = self.today  # datetime.datetime.now().strftime("%Y-%m-%d")
+            path = prfx.format(x=i, y=formatted_date)
+            self.获取直播间用户数据(resource_id, self.root / "数据表" / path)
+
+    # 20240206 新增【针对打卡部分
+    def 获取打卡id(self):
+        """ 依据打卡链接，获取activity_id(打卡id)
+        """
+        打卡链接 = self.打卡链接[1:]
+        ls_activity_id = []
+        for item in 打卡链接:  # 课次
+            activity_id = re.search(r"\?activity_id=(.+?)\&", item)
+            ls_activity_id.append(activity_id.group(1))
+        return ls_activity_id
+
+    def 获取打卡参与用户(self, activity_id, path):
+        # 1）如果路径中已经有了，就跳过
+        if path.is_file():
+            return
+            # 2）获取打卡用户数据：
+        lst = self.xe.get_elock_actor(activity_id)
+        fieldnames = ['用户id', '用户昵称', '打卡昵称', '打卡分组', '姓名', '电话', '最近采集号码', '城市', '微信号',
+                      '打卡天数', '打卡次数', '被点赞数', '被评论数', '被点评数', '被精选数', '参与时间']
+        p = path
+        with open(p, mode='w', newline='', encoding='utf-8') as file:
+            writer = csv.DictWriter(file, fieldnames=fieldnames)
+            writer.writeheader()
+            for x in lst:
+                record = {
+                    '用户id': x['user_id'],
+                    '用户昵称': x['wx_nickname'],
+                    '打卡昵称': x['clock_nickname'],
+                    '打卡分组': None,
+                    '姓名': x['wx_nickname'],
+                    '电话': x['phone'],
+                    '最近采集号码': None,
+                    '城市': x['wx_city'],
+                    '微信号': None,
+                    '打卡天数': x['clock_days'],
+                    '打卡次数': x['clock_days'],
+                    '被点赞数': x['zan_count'],
+                    '被评论数': x['comment_count'],
+                    '被点评数': x['review_count'],
+                    '被精选数': 0,
+                    '参与时间': x['created_at']
+                }
+                writer.writerow(record)
+
+    def 下载打卡数据(self):
+        prfx = "{x}-" + f"《{self.返款标题}技术公益网课【中心教室】-日历打卡学员数据.csv"
+        lt = self.获取打卡id()
+        for i in tqdm(range(1)):
+            activity_id = lt[i]
+            formatted_date = self.today  # datetime.datetime.now().strftime("%Y-%m-%d")
+            path = prfx.format(x=formatted_date)
+            self.获取打卡参与用户(activity_id, self.root / "数据表" / path)
+
+
 class KqDb(Connection):
     """ 五一身心行修考勤工具 """