飞书API 2-7：如何将 MySQL 数据库的查询结果写入多维表（下）

已于 2024-08-04 12:11:51 修改
阅读量1.7k 收藏 14
点赞数 27
CC 4.0 BY-SA版权
分类专栏： 飞书API解读 文章标签： 数据库 飞书 mysql
于 2024-08-04 12:11:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45476428/article/details/140451158

一、引入

上一篇，解决了数据持续插入更新的问题。在一些场景下，如果数据量较大，需要跑多个任务调用接口插入，但是逐个跑任务又太久，又该怎么提高执行速度呢？
没错！就是多线程。

本文就来探讨下怎么使用多线程来完成多任务的更新操作。

二、测试使用多线程

本次使用 Python 的一个标准库concurrent，无序额外安装，直接调用即可。

2.1 任务正常执行

为了方便测试观察效果，这里使用上一篇最后代码中的insert_records()函数进行改装。参考如下：

import time,random

def insert_records(access_token,app_token,table_id,request_body,task_id):
    print('开始插入……',task_id)
    time.sleep(2)
    print('完成调用……',task_id)
    print(f"成功插入第 {task_id} 任务的数据。关联函数：insert_records。")
    return task_id

新增一个函数，用于多线程调用插入函数，创建 3 个 worker 跑任务，使用wait()方法等待任务都提交并执行结束，然后使用as_completed()方法获取执行结果，并打印：

from concurrent.futures import ThreadPoolExecutor, as_completed
import concurrent.futures

def multi_threading_task(access_token,app_token,table_id,ls_datas, exe_func):
    print('\n【多线程】开始将数据更新到飞书多维表...')
    with ThreadPoolExecutor(max_workers=3) as executor:
        print('任务数：%s' % len(ls_datas))
        all_task = {executor.submit(exe_func, access_token,app_token,table_id,ls_datas[task_id], task_id): task_id for task_id in range(len(ls_datas))}
        concurrent.futures.wait(all_task)

        for future in as_completed(all_task):
            task_id = future.result()
            print('返回结果：%s' % task_id)

使用以下代码调用上面 2 个函数。

access_token = ''
app_token = ''
table_id = ''
ls_datas = [i for i in range(5)]
exe_func = insert_records
multi_threading_task(access_token,app_token,table_id,ls_datas, exe_func)

执行结果如下：
image.png

2.2 异常监控处理

在实际生产过程可能会出现任务异常，一般会有两种异常：

  • 调用接口失败：如access_token 无效等；
  • 调用接口成功，但是更新数据失败：如请求体错误等。

针对这两种情况，需要对执行的的任务进行监控，一旦发生异常需要对异常进行处理。前者可通过try…except…捕获错误，后者则通过返回的错误码（“code”）判断。
注意：第一种情况会抛出错误中断执行，第二类仅给错误信息，仍可继续执行。

在代码结构设计上，insert_records()函数依旧完成数据插入功能即可，而在多线程函数multi_threading_task()需要加上上面两种异常情况的处理，并且另外新增一个函数，用于处理失败的任务重跑。

完善insert_records()函数，模拟加入上面涉及的两种错误：

  • 第一类错误：获取当前秒数，等于30时抛出错误；
  • 第二类错误：给你一个列表，code 从列表中随机取值，当 code == 1 打印错误，需要将 code 返回，以便后续判断是否执行成功。
import time,random

def insert_records(access_token,app_token,table_id,request_body,task_id):
    print('开始插入……',task_id)
    time.sleep(2)
    # 模拟第一类错误，获取当前秒数，等于30时抛出错误
    seconds = int(time.time()) % 60
    if seconds == 30:
        print(seconds)
        raise '触发第一类错误：调用失败'
    else:
        print('完成调用……',task_id)
    # 模拟第二类错误：当 code == 1 打印错误
    code = random.choice([0,0,0,0,0,0,0,0,0,1])
    if code == 0:
        print(f"成功插入第 {task_id} 任务的数据。关联函数：insert_records。")
    else:
        print('触发第二类错误：更新失败',task_id)
    return task_id, code

迭代多线程函数，使用try…except…捕获第一类错误，通过返回的错误码判断，获取第二类错误，并将这两类错误的任务 ID 和对应的请求体数据记录下来，然后调用失败重跑函数。

from concurrent.futures import ThreadPoolExecutor, as_completed
import concurrent.futures

def multi_threading_task(access_token,app_token,table_id,ls_datas, exe_func):
    print('\n【多线程】开始将数据更新到飞书多维表...')
    failed_tasks = {}		# 用于记录失败的任务，结构{task_id:ls_datas[task_id]}
    with ThreadPoolExecutor(max_workers=3) as executor:
        print('任务数：%s' % len(ls_datas))
        
        all_task = {executor.submit(exe_func, access_token,app_token,table_id,ls_datas[task_id], task_id): task_id for task_id in range(len(ls_datas))}
        concurrent.futures.wait(all_task)

        for future in as_completed(all_task):
            task_id = future.result()
            print('返回结果：%s' % task_id)
            try:
                task_id, code = future.result()
                #飞书返回错误码，不报错，需要加一层判断。
                if code == 0:
                    print(f"任务 {task_id} 成功")
                elif res_code != 0:
                    failed_tasks[task_id] = ls_datas[task_id]
                    print(f'任务 {task_id} 失败，飞书返回的code：{code}。')
            except Exception as e:
                task_id = all_task[future]
                print(f"调用失败！！！任务 {task_id} 调用接口失败: {e}")
                failed_tasks[task_id] = ls_datas[task_id]
    redo_failed_tasks(access_token,app_token,table_id,failed_tasks, exe_func)
    
def rerun_failed_tasks(access_token,app_token,table_id,failed_tasks, exe_func, rerun_num=3):
    pass

事实上，失败重跑函数和multi_threading_task()的处理逻辑差不多，直接使用它来进行完善即可，不必重写一个函数，参考代码如下。

  • ls_datas是所有请求体数据，根据前面的处理逻辑，返回的结构是列表，每个元素都是一个请求体，视为一个任务。后续任务失败返回的结构是字典，键为任务 ID，值为请求体，保证任务 ID 的编号和原始请求体的编号一致。提交任务时，根据类型遍历取出每一个任务提交；
  • 为了给重跑任务不同的提示，新增两个分支判断，结合上一点，重跑的任务的标识为ls_datas为字典时；
  • 在最后加了一个重跑次数的设置，默认重跑 3 次。
from concurrent.futures import ThreadPoolExecutor, as_completed
import concurrent.futures

redo_cnt = 0

def multi_threading_task(access_token,app_token,table_id,ls_datas, exe_func,redo_num=3):
    global redo_cnt
    print('\n【多线程】开始将数据更新到飞书多维表...')
    print('---------------------------------------------------------')
    failed_tasks = {}		# 用于记录失败的任务，结构{task_id:ls_datas[task_id]}
    with ThreadPoolExecutor(max_workers=3) as executor:
        print('任务数：%s' % len(ls_datas))
        all_task = ''
        if isinstance(ls_datas,list):
            all_task = {executor.submit(exe_func, access_token,app_token,table_id,ls_datas[task_id], task_id): task_id for task_id in range(len(ls_datas))}
        elif isinstance(ls_datas,dict):
            all_task = {executor.submit(exe_func, access_token,app_token,table_id,ls_datas[task_id], task_id): task_id for task_id in ls_datas}
        concurrent.futures.wait(all_task)

        for future in as_completed(all_task):
            try:
                task_id, code = future.result()
                #飞书返回错误码，不报错，需要加一层判断。
                if isinstance(ls_datas,dict) and code == 0:
                    print(f"重跑任务 {task_id} 成功")
                elif isinstance(ls_datas,dict) and code != 0:
                    failed_tasks[task_id] = ls_datas[task_id]
                    print(f'重跑任务:{task_id} 依旧失败，飞书返回的code：{code}。')
                elif code == 0:
                    print(f"任务 {task_id} 成功")
                elif code != 0:
                    failed_tasks[task_id] = ls_datas[task_id]
                    print(f'任务 {task_id} 失败，飞书返回的code：{code}。')
            except Exception as e:
                task_id = all_task[future]
                print(f"调用失败！！！任务 {task_id} 调用接口失败: {e}")
                failed_tasks[task_id] = ls_datas[task_id]
    if failed_tasks:
        redo_cnt += 1
        if redo_cnt == redo_num + 1:
            key = ','.join([str(task_id) for task_id in failed_tasks.keys()])
            print('重跑次数超过3次，以下任务重跑三次依旧报错：',key)
            raise "重跑三次依旧报错"
        multi_threading_task(access_token,app_token,table_id,failed_tasks, exe_func)

2.3 测试代码小结和执行结果

将 2.2 代码整合，为了方便观察错误的发生，修改了触发两类错误的条件，使得发生的概率更大。

from concurrent.futures import ThreadPoolExecutor, as_completed
import concurrent.futures
import time,random

def insert_records(access_token,app_token,table_id,request_body,task_id):
    print('开始插入……',task_id)
    time.sleep(2)
    # 模拟第一类错误，获取当前秒数，等于30时抛出错误
    seconds = int(time.time()) % 60
    # if seconds == 30:
    if seconds in(28,29,30,31,32,33):
        print(seconds)
        raise '触发第一类错误：调用失败'
    else:
        print('完成调用……',task_id)
    # 模拟第二类错误：当 code == 1 打印错误
    code = random.choice([0,0,0,1,1,1,1,1,1,1])
    if code == 0:
        print(f"成功插入第 {task_id} 任务的数据。关联函数：insert_records。")
    else:
        print('触发第二类错误：更新失败',task_id)
    return task_id, code

def multi_threading_task(access_token,app_token,table_id,ls_datas, exe_func,redo_num=3):
    global redo_cnt
    print('\n【多线程】开始将数据更新到飞书多维表...')
    print('---------------------------------------------------------')
    failed_tasks = {}		# 用于记录失败的任务，结构{task_id:ls_datas[task_id]}
    with ThreadPoolExecutor(max_workers=3) as executor:
        print('任务数：%s' % len(ls_datas))
        all_task = ''
        if isinstance(ls_datas,list):
            all_task = {executor.submit(exe_func, access_token,app_token,table_id,ls_datas[task_id], task_id): task_id for task_id in range(len(ls_datas))}
        elif isinstance(ls_datas,dict):
            all_task = {executor.submit(exe_func, access_token,app_token,table_id,ls_datas[task_id], task_id): task_id for task_id in ls_datas}
        concurrent.futures.wait(all_task)

        for future in as_completed(all_task):
            try:
                task_id, code = future.result()
                #飞书返回错误码，不报错，需要加一层判断。
                if isinstance(ls_datas,dict) and code == 0:
                    print(f"重跑任务 {task_id} 成功")
                elif isinstance(ls_datas,dict) and code != 0:
                    failed_tasks[task_id] = ls_datas[task_id]
                    print(f'重跑任务:{task_id} 依旧失败，飞书返回的code：{code}。')
                elif code == 0:
                    print(f"任务 {task_id} 成功")
                elif code != 0:
                    failed_tasks[task_id] = ls_datas[task_id]
                    print(f'任务 {task_id} 失败，飞书返回的code：{code}。')
            except Exception as e:
                task_id = all_task[future]
                print(f"调用失败！！！任务 {task_id} 调用接口失败: {e}")
                failed_tasks[task_id] = ls_datas[task_id]
    if failed_tasks:
        redo_cnt += 1
        if redo_cnt == redo_num + 1:
            key = ','.join([str(task_id) for task_id in failed_tasks.keys()])
            print('重跑次数超过3次，以下任务重跑三次依旧报错：',key)
            raise "重跑三次依旧报错"
        multi_threading_task(access_token,app_token,table_id,failed_tasks, exe_func)


redo_num = 3
redo_cnt = 0
access_token = ''
app_token = ''
table_id = ''
ls_datas = [i for i in range(5)]
exe_func = insert_records
multi_threading_task(access_token,app_token,table_id,ls_datas, exe_func,redo_num)

上面代码某一次执行的完整执行记录参考如下：

  • 一开始所有任务都触发了第一类错误；
  • 第一次重跑：任务 0 触发了第二类错误，任务 1、2、4 触发了第一类错误，只有任务 3 重跑成功；
  • 第二次重跑：任务 0、1、2 触发了第二类错误，只有任务 4 重跑成功；
  • 第三次重跑：任务 0、1、2 触发了第二类错误；
  • 第四次重跑：保错，超过三次。
【多线程】开始将数据更新到飞书多维表...
---------------------------------------------------------
任务数：5
开始插入…… 0
开始插入…… 1
开始插入…… 2
29
29
29
开始插入…… 3
开始插入…… 4
31
31
调用失败！！！任务 1 调用接口失败: exceptions must derive from BaseException
调用失败！！！任务 4 调用接口失败: exceptions must derive from BaseException
调用失败！！！任务 2 调用接口失败: exceptions must derive from BaseException
调用失败！！！任务 0 调用接口失败: exceptions must derive from BaseException
调用失败！！！任务 3 调用接口失败: exceptions must derive from BaseException

【多线程】开始将数据更新到飞书多维表...
---------------------------------------------------------
任务数：5
开始插入…… 1
开始插入…… 4
开始插入…… 2
33
33
开始插入…… 0
开始插入…… 3
33
完成调用…… 0
完成调用…… 3
触发第二类错误：更新失败 0
成功插入第 3 任务的数据。关联函数：insert_records。
重跑任务:0 依旧失败，飞书返回的code：1。
调用失败！！！任务 1 调用接口失败: exceptions must derive from BaseException
调用失败！！！任务 4 调用接口失败: exceptions must derive from BaseException
重跑任务 3 成功
调用失败！！！任务 2 调用接口失败: exceptions must derive from BaseException

【多线程】开始将数据更新到飞书多维表...
---------------------------------------------------------
任务数：4
开始插入…… 0
开始插入…… 1
开始插入…… 4
完成调用…… 0
完成调用…… 4
成功插入第 4 任务的数据。关联函数：insert_records。
完成调用…… 1
开始插入…… 2
触发第二类错误：更新失败 1
触发第二类错误：更新失败 0
完成调用…… 2
触发第二类错误：更新失败 2
重跑任务:2 依旧失败，飞书返回的code：1。
重跑任务:1 依旧失败，飞书返回的code：1。
重跑任务:0 依旧失败，飞书返回的code：1。
重跑任务 4 成功

【多线程】开始将数据更新到飞书多维表...
---------------------------------------------------------
任务数：3
开始插入…… 2
开始插入…… 1
开始插入…… 0
完成调用…… 1
完成调用…… 2
触发第二类错误：更新失败 1
触发第二类错误：更新失败 2
完成调用…… 0
触发第二类错误：更新失败 0
重跑任务:2 依旧失败，飞书返回的code：1。
重跑任务:0 依旧失败，飞书返回的code：1。
重跑任务:1 依旧失败，飞书返回的code：1。
重跑次数超过3次，以下任务重跑三次依旧报错： 2,0,1
Traceback (most recent call last):
  File "g:\git\gitee\my_work\Python\feishu\test\test_mul_threading_task_2.0.py", line 72, in <module>
    multi_threading_task(access_token,app_token,table_id,ls_datas, exe_func,redo_num)
  File "g:\git\gitee\my_work\Python\feishu\test\test_mul_threading_task_2.0.py", line 62, in multi_threading_task
    multi_threading_task(access_token,app_token,table_id,failed_tasks, exe_func)
  File "g:\git\gitee\my_work\Python\feishu\test\test_mul_threading_task_2.0.py", line 62, in multi_threading_task
    multi_threading_task(access_token,app_token,table_id,failed_tasks, exe_func)
  File "g:\git\gitee\my_work\Python\feishu\test\test_mul_threading_task_2.0.py", line 62, in multi_threading_task
    multi_threading_task(access_token,app_token,table_id,failed_tasks, exe_func)
  File "g:\git\gitee\my_work\Python\feishu\test\test_mul_threading_task_2.0.py", line 61, in multi_threading_task
    raise "重跑三次依旧报错"
TypeError: exceptions must derive from BaseException

三、飞书多维表执行多线程任务

将上面标题二的代码逻辑迁移到飞书多维表的更新上，实现多线程跑任务更新飞书多维表。
具体的改动包含三个地方：

  • 三个变更函数：insert_records()、update_records()和delete_records()；
  • 新增多线程函数multi_threading_task()；
  • 最后调用的时候，直接调用多线程函数。

第一处改动：新增参数task_id；数据变更失败时，不要直接抛出错误，改为打印异常信息；返回任务 ID 和状态码。

第二处改动：直接新增多线程函数即可。

第三次改动：main()函数中倒数4行中，遍历调用变更函数（insert_records()、update_records()和delete_records()）的代码修改为调用multi_threading_task()，直接将请求体列表传递即可。另外一个注意点是统计重跑次数的变量redo_cnt，或在main()中定义，然后使用global redo_cnt声明为全局变量，或在函数外直接定义一个全局的redo_cnt变量。
注：以下代码仅展示改动部分，不能直接执行。

from concurrent.futures import ThreadPoolExecutor, as_completed
import concurrent.futures


# ------------------------------------------------------------------------------------------------------------------------
# 第一处改动
def insert_records(access_token,app_token,table_id,request_body,task_id):
    url = f"https://open.feishu.cn/open-apis/bitable/v1/apps/{app_token}/tables/{table_id}/records/batch_create"
    
    payload =  json.dumps(request_body).replace(': NaN',': null')
    
    headers = {
        'Content-Type': 'application/json',
        'Authorization': f'Bearer {access_token}'
    }

    response = requests.request("POST", url, headers=headers, data=payload)
    code = response.json()['code']
    if code == 0:
        len_record = len(request_body["records"])
        print(f"成功插入 {len_record} 数据。关联函数：insert_records。")
    else:
        msg = response.json().get("msg")
        print(f"插入数据失败，失败信息：{msg}。关联函数：insert_records。")
    return task_id, code

def update_records(access_token,app_token,table_id,request_body,task_id):
    url = f"https://open.feishu.cn/open-apis/bitable/v1/apps/{app_token}/tables/{table_id}/records/batch_update"
    payload =  json.dumps(request_body).replace(': NaN',': null')

    headers = {
        'Content-Type': 'application/json',
        'Authorization': f'Bearer {access_token}'
    }

    response = requests.request("POST", url, headers=headers, data=payload)
    code = response.json()['code']
    if code == 0:
        len_record = len(request_body["records"])
        print(f"成功更新 {len_record} 条数据。关联函数：update_records。")
    else:
        msg = response.json().get("msg")
        print(f"更新数据失败，失败信息：{msg}。关联函数：update_records。")
    return task_id, code

def delete_records(access_token,app_token,table_id,request_body,task_id):
    url = f"https://open.feishu.cn/open-apis/bitable/v1/apps/{app_token}/tables/{table_id}/records/batch_delete"
    payload =  json.dumps(request_body)

    headers = {
        'Content-Type': 'application/json',
        'Authorization': f'Bearer {access_token}'
    }

    response = requests.request("POST", url, headers=headers, data=payload)
    code = response.json()['code']
    if code == 0:
        len_record = len(request_body["records"])
        print(f"成功删除 {len_record} 数据。关联函数：delete_records。")
    else:
        msg = response.json().get("msg")
        print(f"更新数据失败，失败信息：{msg}。关联函数：delete_records。")
    return task_id, code

# ------------------------------------------------------------------------------------------------------------------------
# 第二处改动
def multi_threading_task(access_token,app_token,table_id,ls_datas, exe_func,redo_num=3):
    global redo_cnt
    print('\n【多线程】开始将数据更新到飞书多维表...')
    print('---------------------------------------------------------')
    failed_tasks = {}		# 用于记录失败的任务，结构{task_id:ls_datas[task_id]}
    with ThreadPoolExecutor(max_workers=3) as executor:
        print('任务数：%s' % len(ls_datas))
        all_task = ''
        if isinstance(ls_datas,list):
            all_task = {executor.submit(exe_func, access_token,app_token,table_id,ls_datas[task_id], task_id): task_id for task_id in range(len(ls_datas))}
        elif isinstance(ls_datas,dict):
            all_task = {executor.submit(exe_func, access_token,app_token,table_id,ls_datas[task_id], task_id): task_id for task_id in ls_datas}
        concurrent.futures.wait(all_task)

        for future in as_completed(all_task):
            try:
                task_id, code = future.result()
                #飞书返回错误码，不报错，需要加一层判断。
                if isinstance(ls_datas,dict) and code == 0:
                    print(f"重跑任务 {task_id} 成功")
                elif isinstance(ls_datas,dict) and code != 0:
                    failed_tasks[task_id] = ls_datas[task_id]
                    print(f'重跑任务:{task_id} 依旧失败，飞书返回的code：{code}。')
                elif code == 0:
                    print(f"任务 {task_id} 成功")
                elif code != 0:
                    failed_tasks[task_id] = ls_datas[task_id]
                    print(f'任务 {task_id} 失败，飞书返回的code：{code}。')
            except Exception as e:
                task_id = all_task[future]
                print(f"调用失败！！！任务 {task_id} 调用接口失败: {e}")
                failed_tasks[task_id] = ls_datas[task_id]
    if failed_tasks:
        redo_cnt += 1
        if redo_cnt == redo_num + 1:
            key = ','.join([str(task_id) for task_id in failed_tasks.keys()])
            print('重跑次数超过3次，以下任务重跑三次依旧报错：',key)
            raise "重跑三次依旧报错"
        multi_threading_task(access_token,app_token,table_id,failed_tasks, exe_func)

# ------------------------------------------------------------------------------------------------------------------------
# 第三处改动
def main(bitable_url, connect_info, sql, fields_type, foreign_key, data_type=1, page_size=500):
    """前面部分的调用不变，注释掉倒数4行，新增以下未注释代码"""
    # if ls_cre:[insert_records(access_token,app_token,table_id,cre_body) for cre_body in ls_cre]
    # if ls_ups:[update_records(access_token,app_token,table_id,ups_body) for ups_body in ls_ups]
    # if ls_del:[delete_records(access_token,app_token,table_id,del_body) for del_body in ls_del]
    # print('更新完成。关联函数：main')
    global redo_cnt
    redo_cnt = 0
    redo_num = 3
    if ls_cre:multi_threading_task(access_token,app_token,table_id,ls_cre,insert_records,redo_num)
    if ls_ups:multi_threading_task(access_token,app_token,table_id,ls_ups,update_records,redo_num)
    if ls_del:multi_threading_task(access_token,app_token,table_id,ls_del,delete_records,redo_num)
    print('更新完成。关联函数：main')

将改动的内容放到完整代码中，然后在多维表上面对数据进行调整以观察执行结果。
image.png

最终执行结果如下，本次执行未触发异常，如果你想测试一下异常情况，可以增加更多数据，然后跑多一些任务来观察。另外，飞书的 API 还是比较稳定，出错概率比较低。
image.png

注：完整代码我放百度网盘了，需要的同步可以后台回复【飞书27】领取。

四、小结

本文探讨了怎么通过多线程调用飞书 API，从而提高数据更新到飞书多维表的速度。主要通过模拟飞书任务进行测试多线程的功能，跑通之后再迁移到飞书多维表的更新代码上，完成迭代。

经过上中下三篇，终于将如何将 MySQL 数据库的查询结果写入多维表梳理完成。小结一下：

  • 上篇：只做插入功能，适合单次数据更新；
  • 中篇：新增更新和删除功能，基本满足了通用的业务场景；
  • 下篇：新增多线程功能，主要提高执行速度。

五、附录：完整代码

import requests
import json
import datetime
import pandas as pd
from sqlalchemy import create_engine, text
from urllib.parse import urlparse, parse_qs
from concurrent.futures import ThreadPoolExecutor, as_completed
import concurrent.futures

# 读取飞书多维表数据：参考《飞书API（7）：MySQL 入库通用版本》
def get_table_params(bitable_url):
    # bitable_url = "https://feishu.cn/base/aaaaaaaa?table=tblccc&view=vewddd"
    parsed_url = urlparse(bitable_url)              #解析url：(ParseResult(scheme='https', netloc='feishu.cn', path='/base/aaaaaaaa', params='', query='table=tblccc&view=vewddd', fragment='')
    query_params = parse_qs(parsed_url.query)       #解析url参数：{'table': ['tblccc'], 'view': ['vewddd']}
    app_token = parsed_url.path.split('/')[-1]
    table_id = query_params.get('table', [None])[0]
    view_id = query_params.get('view', [None])[0]
    print(f'成功解析链接，app_token：{app_token}，table_id：{table_id}，view_id：{view_id}。关联方法：get_table_params。')
    return app_token, table_id, view_id

def get_tenant_access_token(app_id, app_secret):
    url = "https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal"
    payload = json.dumps({
        "app_id": app_id,
        "app_secret": app_secret
    })
    headers = {'Content-Type': 'application/json'}
    response = requests.request("POST", url, headers=headers, data=payload)
    tenant_access_token = response.json()['tenant_access_token']
    print(f'成功获取tenant_access_token：{tenant_access_token}。关联函数：get_table_params。')
    return tenant_access_token

def get_bitable_datas(tenant_access_token, app_token, table_id, view_id, page_token='', page_size=20):
    url = f"https://open.feishu.cn/open-apis/bitable/v1/apps/{app_token}/tables/{table_id}/records/search?page_size={page_size}&page_token={page_token}&user_id_type=user_id"
    payload = json.dumps({"view_id": view_id})
    headers = {
        'Content-Type': 'application/json',
        'Authorization': f'Bearer {tenant_access_token}'
    }
    response = requests.request("POST", url, headers=headers, data=payload)
    print(f'成功获取page_token为【{page_token}】的数据。关联函数：get_bitable_datas。')
    return response.json()


def get_all_bitable_datas(tenant_access_token, app_token, table_id, view_id, page_token='', page_size=20):
    has_more = True
    feishu_datas = []
    while has_more:
        response = get_bitable_datas(tenant_access_token, app_token, table_id, view_id, page_token, page_size)
        if response['code'] == 0:
            page_token = response['data'].get('page_token')
            has_more = response['data'].get('has_more')
            # print(response['data'].get('items'))
            # print('\n--------------------------------------------------------------------\n')
            feishu_datas.extend(response['data'].get('items'))
        else:
            raise Exception(response['msg'])
    print(f'成功获取飞书多维表所有数据，返回 feishu_datas。关联函数：get_all_bitable_datas。')
    return feishu_datas

# ------------------------------------------------------------------------------------------------------------------------
# 读取数据库数据，参考《飞书API 2-5：如何将 MySQL 数据库的查询结果写入多维表（上）》

def get_datas(sql, connect_info, fields_type):
    # connect_info = 'mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'\
    # .format("your_user_name", "your_password", "127.0.0.1", "3306","my_datas")
    engine = create_engine(connect_info)
    result = pd.read_sql(sql, engine)
    result = result.astype(fields_type,errors='ignore')
    # result.info()
    return result

# def format_to_reqbody(df,change_size=500):
#     df_dict = df.to_dict(orient='records')
#     datas_field = [{'fields' : data} for data in df_dict]

#     df_ls = []
#     for i in range(0,len(datas_field), change_size):
#         data_records = {"records": datas_field[i:i+change_size]}
#         # data_to_table = json.dumps(data_records).replace(': NaN',': null')
#         df_ls.append(data_records)
    
#     print('数据格式化并切割：切割数据集为 %s 份。关联函数：format_to_reqbody' % (len(df_ls)))
#     return df_ls


# ------------------------------------------------------------------------------------------------------------------------------

# 新增格式化、分类与分组
def format_db_datas(df_db, foreign_key):
    """格式化数据库数据：整理为 API 所需格式，并将 外键 提取出来"""
    # 处理为结构 [{foreign_key: <外键值>,'fields' : <所有明细数据>]
    datas_ls = df_db.to_dict(orient='records')
    datas_field = [{foreign_key: data[foreign_key],'fields' : data} for data in datas_ls]
    # 转为DataFrame，以便下 Python SQL 处理
    df_db = pd.DataFrame(datas_field)
    print(f'成功提取【数据库】的关键字段：fields, {foreign_key}。方法：format_db_datas')
    return df_db

def format_feishu_datas(feishu_datas, foreign_key, data_type=1):
    """格式化飞书数据：提取关键字段：外键 和 record_id"""
    if feishu_datas == []:
        #如果飞书多维表没有数据，返回无值的DataFrame
        df_tb = pd.DataFrame(columns=['record_id', foreign_key])
    else:
        df_tb = pd.DataFrame(feishu_datas)
        
        if data_type == 1:
            df_tb[foreign_key] = df_tb['fields'].map(lambda x: x.get(foreign_key)[0]['text'] if x.get(foreign_key) else None)
        elif data_type  in (2, 3, 13, 5):  #数字、单选、手机号、日期
            df_tb[foreign_key] = df_tb['fields'].map(lambda x: x.get(foreign_key) if x.get(foreign_key) else None)
        else:
            raise '暂不支持改类型！'

        # 实际生产过程，可能新增行行为。
        df_tb_ok = df_tb[~df_tb[foreign_key].isna()]
        df_tb_ok = df_tb_ok[['record_id', foreign_key]]
    invalid_num = df_tb[df_tb[foreign_key].isna()].shape[0]
    print(f'成功提取【飞书表单】的关键字段：record_id, {foreign_key}。发现无效数据 {invalid_num} 条。方法：format_feishu_datas')
    return df_tb_ok

def classify_datas(df_from, df_join, on=None, left_on=None, right_on=None):
    """将两个[{},{}]或 DF 结构的数据分类。ls_from 为数据库数据，ls_join 为多维表数据"""    
    if on is not None:
        df_cre = df_from.merge(df_join, how='left' , on=on).query('record_id != record_id')[['fields']] # 等同于'record_id.isnull()'，因为 NaN != NaN
        df_ups = df_from.merge(df_join, how='inner', on=on)[['record_id', 'fields']]
        df_del = df_from.merge(df_join, how='right', on=on).query('fields != fields')[['record_id']] # 等同于'fields.isnull()'，因为 NaN != NaN
    else:
        df_cre = df_from.merge(df_join, how='left' , left_on=left_on, right_on=right_on).query('record_id != record_id')[['fields']] # 等同于'record_id.isnull()'，因为 NaN != NaN
        df_ups = df_from.merge(df_join, how='inner', left_on=left_on, right_on=right_on)
        df_del = df_from.merge(df_join, how='right', left_on=left_on, right_on=right_on).query('fields != fields')[['record_id']] # 等同于'fields.isnull()'，因为 NaN != NaN

    print('数据分类：新增数据集（df_cre）的数据量为 %s, 更新数据集（df_ups）的数据量为 %s, 删除数据集（df_ups）的数据量为 %s。方法：classify_datas' % (df_cre.shape[0], df_ups.shape[0], df_del.shape[0]))
    return df_cre, df_ups, df_del

def cut_datas(df,mode='dict',page_size=500):
    """
    按指定尺寸切分数据，并转为API要求格式
    切割数据：接口数据上限500
    mode: 模式，默认是字典格式 dict（插入/更新结构），即 DF.to_dict(orient='records')。还支持 list（删除结构），即 Series.to_list()
    """
    df_ls = []
    for i in range(0,df.shape[0], page_size):
        if mode=='dict':
            data_records = df.iloc[i:i+page_size].to_dict(orient='records')
        elif mode=='list':
            data_records = df.iloc[i:i+page_size].record_id.to_list()
        #插入和更新都使用该结构
        # data_to_table = json.dumps({"records": data_records}).replace('NaN','null')
        # data_to_table = json.dumps({"records": data_records}).replace(': NaN',': null')  # 使用re也可以，不过大材小用了。
        data_to_table = {"records": data_records}
        # _data_to_table = json.dumps({"records": data_records})
        # data_to_table = re.sub(r': NaN', ': null', _data_to_table)
        df_ls.append(data_to_table)
    print('数据切割：切割数据集为 %s 份。方法：datas_processing.cut_dataset' % (len(df_ls)))
    return df_ls

# -----------------------------------------------------------------------------------------------------------------------
# 第一处改动
def insert_records(access_token,app_token,table_id,request_body,task_id):
    url = f"https://open.feishu.cn/open-apis/bitable/v1/apps/{app_token}/tables/{table_id}/records/batch_create"
    
    payload =  json.dumps(request_body).replace(': NaN',': null')
    
    headers = {
        'Content-Type': 'application/json',
        'Authorization': f'Bearer {access_token}'
    }

    response = requests.request("POST", url, headers=headers, data=payload)
    code = response.json()['code']
    if code == 0:
        len_record = len(request_body["records"])
        print(f"成功插入 {len_record} 数据。关联函数：insert_records。")
    else:
        msg = response.json().get("msg")
        print(f"插入数据失败，失败信息：{msg}。关联函数：insert_records。")
    return task_id, code

def update_records(access_token,app_token,table_id,request_body,task_id):
    url = f"https://open.feishu.cn/open-apis/bitable/v1/apps/{app_token}/tables/{table_id}/records/batch_update"
    payload =  json.dumps(request_body).replace(': NaN',': null')

    headers = {
        'Content-Type': 'application/json',
        'Authorization': f'Bearer {access_token}'
    }

    response = requests.request("POST", url, headers=headers, data=payload)
    code = response.json()['code']
    if code == 0:
        len_record = len(request_body["records"])
        print(f"成功更新 {len_record} 条数据。关联函数：update_records。")
    else:
        msg = response.json().get("msg")
        print(f"更新数据失败，失败信息：{msg}。关联函数：update_records。")
    return task_id, code

def delete_records(access_token,app_token,table_id,request_body,task_id):
    url = f"https://open.feishu.cn/open-apis/bitable/v1/apps/{app_token}/tables/{table_id}/records/batch_delete"
    payload =  json.dumps(request_body)

    headers = {
        'Content-Type': 'application/json',
        'Authorization': f'Bearer {access_token}'
    }

    response = requests.request("POST", url, headers=headers, data=payload)
    code = response.json()['code']
    if code == 0:
        len_record = len(request_body["records"])
        print(f"成功删除 {len_record} 数据。关联函数：delete_records。")
    else:
        msg = response.json().get("msg")
        print(f"更新数据失败，失败信息：{msg}。关联函数：delete_records。")
    return task_id, code

# ------------------------------------------------------------------------------------------------------------------------
# 第二处改动
def multi_threading_task(access_token,app_token,table_id,ls_datas, exe_func,redo_num=3):
    global redo_cnt
    print('\n【多线程】开始将数据更新到飞书多维表...')
    print('---------------------------------------------------------')
    failed_tasks = {}		# 用于记录失败的任务，结构{task_id:ls_datas[task_id]}
    with ThreadPoolExecutor(max_workers=3) as executor:
        print('任务数：%s' % len(ls_datas))
        all_task = ''
        if isinstance(ls_datas,list):
            all_task = {executor.submit(exe_func, access_token,app_token,table_id,ls_datas[task_id], task_id): task_id for task_id in range(len(ls_datas))}
        elif isinstance(ls_datas,dict):
            all_task = {executor.submit(exe_func, access_token,app_token,table_id,ls_datas[task_id], task_id): task_id for task_id in ls_datas}
        concurrent.futures.wait(all_task)

        for future in as_completed(all_task):
            try:
                task_id, code = future.result()
                #飞书返回错误码，不报错，需要加一层判断。
                if isinstance(ls_datas,dict) and code == 0:
                    print(f"重跑任务 {task_id} 成功")
                elif isinstance(ls_datas,dict) and code != 0:
                    failed_tasks[task_id] = ls_datas[task_id]
                    print(f'重跑任务:{task_id} 依旧失败，飞书返回的code：{code}。')
                elif code == 0:
                    print(f"任务 {task_id} 成功")
                elif code != 0:
                    failed_tasks[task_id] = ls_datas[task_id]
                    print(f'任务 {task_id} 失败，飞书返回的code：{code}。')
            except Exception as e:
                task_id = all_task[future]
                print(f"调用失败！！！任务 {task_id} 调用接口失败: {e}")
                failed_tasks[task_id] = ls_datas[task_id]
    if failed_tasks:
        redo_cnt += 1
        if redo_cnt == redo_num + 1:
            key = ','.join([str(task_id) for task_id in failed_tasks.keys()])
            print('重跑次数超过3次，以下任务重跑三次依旧报错：',key)
            raise "重跑三次依旧报错"
        multi_threading_task(access_token,app_token,table_id,failed_tasks, exe_func)

def get_tenant_access_token(app_id, app_secret):
    url = "https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal"
    payload = json.dumps({
        "app_id": app_id,
        "app_secret": app_secret
    })
    headers = {'Content-Type': 'application/json'}
    response = requests.request("POST", url, headers=headers, data=payload)
    tenant_access_token = response.json()['tenant_access_token']
    print(f'成功获取tenant_access_token：{tenant_access_token}。关联函数：get_table_params。')
    return tenant_access_token


def main(bitable_url, connect_info, sql, fields_type, foreign_key, data_type=1, page_size=500):
    # 基本配置
    app_token, table_id, view_id = get_table_params(bitable_url)
    app_id = 'your_app_id'
    app_secret = 'your_app_secret'
    access_token = get_tenant_access_token(app_id, app_secret)    
    
    # 读取数据库数据并格式化
    df_db = get_datas(sql, connect_info, fields_type)
    df_from = format_db_datas(df_db, foreign_key)
    # 读取多维表数据并格式化
    feishu_datas = get_all_bitable_datas(access_token, app_token, table_id, view_id, page_size=page_size)
    df_join = format_feishu_datas(feishu_datas, foreign_key, data_type)
    # 数据分类
    df_cre, df_ups, df_del = classify_datas(df_from, df_join, on=foreign_key)

    ls_cre = cut_datas(df_cre,mode='dict',page_size=page_size)
    ls_ups = cut_datas(df_ups,mode='dict',page_size=page_size)
    ls_del = cut_datas(df_del,mode='list',page_size=page_size)
    
    global redo_cnt
    redo_cnt = 0
    redo_num = 3
    if ls_cre:multi_threading_task(access_token,app_token,table_id,ls_cre,insert_records,redo_num)
    if ls_ups:multi_threading_task(access_token,app_token,table_id,ls_ups,update_records,redo_num)
    if ls_del:multi_threading_task(access_token,app_token,table_id,ls_del,delete_records,redo_num)
    print('更新完成。关联函数：main')

if __name__ == '__main__':
    bitable_url = 'https://vl933ry4wy.feishu.cn/base/EPYFbi4ThahvLUsJ9nUchaXQnLh?table=tblnE4CHrysoKYNO&view=vewH9qJSRL'
    connect_info = 'mysql+pymysql://{}:{}@{}:{}/{}?charset=utf8'\
                .format("root", "123456", "127.0.0.1", "3306","my_datas")
    sql = '''
    select uo.user_id                               as "用户ID"
      ,u.nickname                                   as "昵称"
      ,(case u.sex when 0 then '女' when 1 then '男' else '未知' end) as "性别"
      ,u.mobile                                     as "手机号"
      ,u.city                                       as "城市"
      ,uo.id                                        as "订单号"
      ,uo.paid_time*1000                            as "下单时间"
      ,uo.amount/100                                as "下单金额"
    from my_datas.user_orders uo
    join my_datas.users u on u.id=uo.user_id
    where uo.production_id=10;
    '''
    fields_type = {"用户ID": int, "昵称": str, "性别": str, "手机号": str, "城市": str, "订单号": int, "下单时间": 'int64', "下单金额": float}
    foreign_key ='订单号'
    data_type = 2
    page_size = 2
    main(bitable_url, connect_info, sql, fields_type, foreign_key, data_type, page_size)

:::info
飞书API 2-7 大纲

  • 引入：问题：如果数据量比较大，如何提高速度？
  • 使用多线程
    • 多线程设置：先不加ID
    • 异常监控处理：加ID，以便识别处理
  • 小结
    :::
Prometheus基于kubernetes实现监控告警---飞书告警（告警规则最全）
weixin_43273856的博客
11-03 2577
Prometheus基于kubernetes实现监控告警---飞书告警
飞书API 2-5：如何将 MySQL 数据库的查询结果写入多维表（上）
明而决之
07-15 4440
本文完整探讨了使用 MySQL 数据库+ Pandas 库 + 飞书应用实现了业务的一个数据需求：将某产品的用户数据同步到飞书表上。 整个流程涉及了五大步骤： 目标分析：将需求数据同步到飞书多维表协作 创建飞书数据表：分析需求字段的类型、数据格式等 查询数据库数据：连表查询数据并对数据值和字段名进行格式化 Pandas处理数据：将格式化的数据转为 API 需求的请求体的格式 写入飞书多维表：调用飞书新增多行记录的 API，将数据写入飞书多维表
飞书API 2-6：如何将 MySQL 数据库的查询结果写入多维表（中）
明而决之
07-24 2060
接上一篇，已经解决了单向的数据传输问题，即：将 MySQL 的数据写入到多维表。但是如果需求具有持续性，换句话说，每隔一段时间需要同步一次数据，今天需要同步数据，明天还需要同步数据，又该怎么办？本文针对这两种同步策略展开探讨下如何持续同步数据。
飞书API 2-2：如何使用 API 建多维表
明而决之
06-22 4041
本文探讨了如何通过 API 创建多维表。 具体操作如下： 获得文件夹的权限 应用配置：在应用后台开启机器人的能力 创建群组：专用于文件夹授权 群组配置：添加应用机器人 文件夹授权：分享给新建的群组 使用 API 创建多维表 其中，应用和群组配置可以视为一次性操作，后续只需要进行文件夹给群组授权，便可以使用 API 创建多维表。
飞书API（2）：通过 Python 读取多维表数据
明而决之
03-31 1万+
使用 Python 自动读取多维表主要分两步： 第一步是取应用的 app_id 和 app_secret 获取临时 tenant_access_token，传递给第二步； 第二步是取 tenant_access_token 加上 多维表的标识（app_token、table_id）读取数据。
python使用飞书开发平台api，爬取多维表格或者电子表格的数据，并写到本地文件
m0_71695472的博客
07-21 6039
第一次看这种api文档来书写代码完成业务逻辑，并且我本身是用的java语言，对于python并不是很熟悉，使用python代码写的并不是很好，只是看见csdn上面关于飞书api的帖子较少，（当时自己也搜过，没有看见自己想要的），所以才写了这个博客（也是自己第一次写），希望给大家做一个参考，如果有什么问题的话，也希望大家指正。使用飞书开发平台提供的api接口，去爬取多维表格的数据，并保存在本地，也可以爬取电子表格的数据，但是电子表格的相关api在我使用的时候是不提供调试的。
Bussiness-Inteligence:尝试2
03-30
1. 数据访问与处理：C#通过ADO.NET库可以直接与各种数据库（如SQL Server、Oracle、MySQL等）交互，进行数据的读取、写入和更新操作。这在BI项目中至关重要，因为数据的获取和预处理是分析的第一步。 2. 数据分析与...
飞书多维表格连接数据库
最新发布
05-23
以下是一个完整的示例代码，展示如何从数据库读取数据并通过 API 将其写入飞书多维表格。 ##### (1) 导入库 加载所需的模块以便执行后续功能。 ```python import pandas as pd from sqlalchemy import create_...
lab-6-genericschooluser:GitHub Classroom创建的lab-6-genericschooluser
03-29
4. **数据库交互**：PHP常与MySQL等数据库进行交互，使用`mysqli`或`PDO`扩展实现SQL查询、插入、更新和删除数据。例如，`mysqli_connect()`用于建立连接，`mysqli_query()`执行SQL语句。 5. **HTTP和Web服务**：...
：MySQL数据库导出与数据集成：整合异构数据源，构建统一数据视图
MySQL数据库导出是指将数据库中的数据和结构提取并保存到外部文件中，以便备份、迁移或其他目的。导出操作可以分为物理导出和逻辑导出两种方式。 物理导出通过直接复制数据库文件或使用mysqldump工具将数据库中的...
腾讯、飞书等在线表格自动化编辑--python
热门推荐
qq_32828053的博客
07-13 2万+
在线文档自动化处理数据
一步到位！dify + Python+飞书多维表格实现火车票/发票信息自动录入
wind1_rain的博客
03-25 1095
虽然前面实现了识别火车票和发票的信息，但是，输出的是text。使用还需要复制到表格中，可以更简单吗？当然是可以，这篇文章教你：​ 识别火车票，直接把信息录入：表格。一步到位。最终效果：话不多说，开始实战吧。
飞书 API 2-4：如何使用 API 将数据写入数据表
明而决之
07-07 7204
上一篇创建好数据表之后，接下来就是写入数据和对数据的处理。本文主要探讨数据的插入、更新和删除操作。所有的操作都是基于上一篇（飞书 API 2-4）创建的数据表进行操作。上面最终的数据表只有 2 个字段：序号和邮箱。序号是多维表自动填充的自增数字，所以我们处理的时候不需要处理该字段，只需要处理邮箱即可。
第十章 golang http操作
qq_24430629的博客
06-15 2348
发送http请求
飞书API（1）-读取飞书多维表数据
明而决之
03-25 7389
本文介绍如何通过飞书 API 读取飞书多维表的数据，从创建应用到发布，再到 API 调试。详细流程如下：1、创建应用2、申请权限，发布版本3、创建多维表，并设置应用操作多维表的权限4、查看接口文档，并调试 API。
飞书API（7）：MySQL 入库通用版本
明而决之
05-04 2452
本文完成了飞书多维表数据写入 MySQL 数据库的通用版本代码的开发，经过对代码进行重构，把三组核心关系：飞书列名和数据类型、飞书列名和入库表单字段名、飞书数据类型和入库字段的数据类型解耦出来，使得代码通用性更强。
免费白嫖飞书云数据库-python连接飞书多维表格
2401_89766427的博客
12-18 1929
多维表格可以创建很多个数据表，我们的程序可以把数据接入到多维表格中，实现免费的数据库，并且多维表格的视图功能非常丰富，可以0代码自建多种后台视图，数据管理还能使用AI功能，智能化提取分析数据。而选择自建应用相当于选择管理员A或管理员B的身份来操作，每个应用的权限可能会不一样，所以能够有效做到安全隔离。多维表格相当于数据库（APP_TOKEN)，而数据库里面有很多数据表(TABLE_ID)。自建应用是用来操作表格数据的，有了它我们才有权限读写数据，类似于后台管理员。集合是健(key)是固定的。
飞书API 2-3：如何使用 API 创建数据表，解放人工？
明而决之
06-30 2992
作为飞书多维表的深度使用者，经常需要将一些数据库的数据同步到多维表上，在数据写入之前，一般需要新建数据表和字段。当通过网页端界面新建字段时，如果字段少，还能接受手动一个个创建，不过一旦字段比较多，操作起来特别繁琐，机械地重复着，有点怀疑人生。这种情况下，急需一个更加自动化的方式来解决！这不，飞书官方便提供了这样的 API 方便我们快速建数据表和字段。
MySQL数据库中的视图数据导入到飞书的多维表格中
qq_49894233的博客
04-16 799
1.手动导出 + 上传文件适合数据量小，一次性导入。无需编程，操作简单，但是，效率低，不适合频繁同步。2.飞书API + 脚本自动同步适合数据量大，需定时/实时同步。自动化，可定制化，但是需要开发能力，API学习成本。3.第三方工具（如Zapier）适合无编程经验，快速集成。图形化操作，无需代码，但是可能有费用，依赖工具功能。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Xin学数据

为你点亮一盏灯，愿你前进无阻。

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值