funboost 49.2__tar.gz → 49.3__tar.gz

{funboost-49.2/funboost.egg-info → funboost-49.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: funboost
-Version: 49.2
+Version: 49.3
 Summary: pip install funboost，python全功能分布式函数调度框架,funboost的功能是全面性重量级，用户能想得到的功能99%全都有;funboost的使用方式是轻量级，只有@boost一行代码需要写。支持python所有类型的并发模式和一切知名消息队列中间件，支持如 celery dramatiq等框架整体作为funboost中间件，python函数加速器，框架包罗万象，用户能想到的控制功能全都有。一统编程思维，兼容50% python业务场景，适用范围广。只需要一行代码即可分布式执行python一切函数，funboost web manager 方便查看和管理消费函数；99%用过funboost的pythoner 感受是　简易 方便 强劲 强大，相见恨晚 
 Home-page: https://github.com/ydf0509/funboost
 Author: bfzs
@@ -73,8 +73,10 @@ Broker。funboost源码高扩展性的设计，造成“万物皆可为Broker”
 框架对代码没有入侵,可以加到任意已有项目而对项目python文件目录结构0要求,
 不像 celery django scrapy 这样的框架,要从一开始就开始规划好项目目录结构,如果不想用框架了,
 或者想改变使用其他框架框架,那么已经所写的代码组织形式就几乎成了废物,需要大改特改. 
-但是funboost完全不会这样,加上或去掉@boost装饰器,对你的项目影响为0,用户照常使用,
+但是funboost完全不会这样,就算是加上或去掉@boost装饰器,对你的项目影响为0,用户照常使用,
 所以用户可以对任意项目,任意时候,引入使用funboost或者去掉使用funboost,代码组织形式不需要发生变化.
+（即使不想用funboost了，也不需要亲自去掉@boost装饰器，因为函数有@boost装饰器对函数自身的直接调用运行没有任何影响，
+用户照样可以直接例如 fun(x,y)是直接运行函数 ， fun.push(x,y) 才是发送到消息队列）
 
 通过funboost web manager 管理系统，支持全面 查看 监控 管理 funboost的任务消费。
 </pre>
@@ -486,26 +488,32 @@ if __name__ == "__main__":
 
 
 
-## 1.3.2 funboost丝滑连续启动多个函数消费
+## 1.3.2 funboost集中演示一个功能更多的综合例子
 
 ```python
 
+
 """
-此代码
-1.演示支持多个函数消费队列的无阻塞启动（consume不会阻塞主线程）
-2.演示支持在一个消费函数内部向任意队列发布新任务，实现多级任务链
-代码结构清晰，扩展性极强
+一个展示更全面 funboost 用法的例子
+包含了
+1.继承BoosterParams，为了每个装饰器少写入参
+2.rpc获取结果
+3.连续丝滑启动多个消费函数
+4.定时任务
 """
-from funboost import boost, BrokerEnum,BoosterParams,ctrl_c_recv,ConcurrentModeEnum
+from funboost import boost, BrokerEnum,BoosterParams,ctrl_c_recv,ConcurrentModeEnum,ApsJobAdder
 import time
 
 class MyBoosterParams(BoosterParams):  # 自定义的参数类，继承BoosterParams，用于减少每个消费函数装饰器的重复相同入参个数
-    broker_kind: str = BrokerEnum.MEMORY_QUEUE
+    broker_kind: str = BrokerEnum.REDIS_ACK_ABLE
     max_retry_times: int = 3
     concurrent_mode: str = ConcurrentModeEnum.THREADING 
 
     
-@boost(MyBoosterParams(queue_name='s1_queue', qps=1, ))
+@boost(MyBoosterParams(queue_name='s1_queue', qps=1, 
+                    #    do_task_filtering=True, # 可开启任务过滤，防止重复入参消费。
+                       is_using_rpc_mode=True, # 开启rpc模式，支持rpc获取结果
+                       ))
 def step1(a:int,b:int):
     print(f'a={a},b={b}')
     time.sleep(0.7)
@@ -514,20 +522,75 @@ def step1(a:int,b:int):
     return a+b
 
 
-@boost(MyBoosterParams(queue_name='s2_queue', qps=3, ))
-def step2(c:int,d:int,e:int):
+@boost(MyBoosterParams(queue_name='s2_queue', qps=3, 
+                      max_retry_times=5，# 可以在此覆盖MyBoosterParams中的默认值，例如为step2单独设置最大重试次数为5
+)) 
+def step2(c:int,d:int,e:int=666):
     time.sleep(3)
     print(f'c={c},d={d},e={e}')
     return c* d * e
 
 
 if __name__ == '__main__':
-    for i in range(100):
-        step1.push(i,i*2) # 向 step1函数的队列发送消息。
+    step1.clear() # 清空队列
+    step2.clear() # 清空队列
+
     step1.consume() # 调用.consume是非阻塞的启动消费，是在单独的子线程中循环拉取消息的。 
     # 有的人还担心阻塞而手动使用 threading.Thread(target=step1.consume).start() 来启动消费，这是完全多此一举的错误写法。
-    step2.consume() # 所以可以连续无阻塞丝滑的启动多个函数消费。
-    ctrl_c_recv()
+    step2.consume() # 所以可以在当前主线程连续无阻塞丝滑的启动多个函数消费。
+    step2.multi_process_consume(3) # 这是多进程叠加了多线程消费，另外开启了3个进程，叠加了默认的线程并发。
+
+    async_result = step1.push(100,b=200)
+    print('step1的rpc结果是：',async_result.result)  # rpc阻塞等待消step1的费结果返回
+
+    for i in range(100):
+        step1.push(i,i*2) # 向 step1函数的队列发送消息,入参和手动调用函数那样很相似。
+        step1.publish ({'a':i,'b':i*2},task_id=f'task_{i}') # publish 第一个入参是字典，比push能传递更多funboost的辅助参数，类似celery的apply_async和delay的关系。一个简单，一个复杂但强大。
+    
+    
+
+    """
+    1.funboost 使用 ApsJobAdder.add_push_job来添加定时任务，不是add_job。
+    2.funboost是轻度封装的知名apscheduler框架，所以定时任务的语法和apscheduler是一样的，没有自己发明语法和入参
+    用户需要苦学apscheduler教程，一切定时都是要学apscheduler知识，定时和funboost知识关系很小。
+    3.funboost的定时任务目的是定时推送消息到消息队列中，而不是定时直接在当前程序中执行某个消费函数。
+
+    下面是三种方式添加定时任务，这些定时方式都是知名apscheduler包的定时方式，和funboost没关系。
+    """
+    # 方式1：指定日期执行一次
+    ApsJobAdder(step2, 
+               job_store_kind='redis', # 使用reids作为 apscheduler的 jobstrores
+               is_auto_start=True,   # 添加任务，并同时顺便启动了定时器 执行了apscheduler对象.start()
+    ).add_push_job(
+        trigger='date',
+        run_date='2025-06-30 16:25:40',
+        args=(7, 8,9),
+        id='date_job1',
+        replace_existing=True,
+    )
+
+    # 方式2：固定间隔执行
+    ApsJobAdder(step2, job_store_kind='redis').add_push_job(
+        trigger='interval',
+        seconds=30,
+        args=(4, 6,10),
+        id='interval_job1',
+        replace_existing=True,
+    )
+
+    # 方式3：使用cron表达式定时执行
+    ApsJobAdder(step2, job_store_kind='redis').add_push_job(
+        trigger='cron',
+        day_of_week='*',
+        hour=23,
+        minute=49,
+        second=50,
+        kwargs={"c": 50, "d": 60,"e":70},
+        replace_existing=True,
+        id='cron_job1')
+    
+    ctrl_c_recv()  # 用于阻塞代码，阻止主线程退出，使主线程永久运行。  相当于 你在代码最末尾，加了个 while 1:time.sleep(10)，使主线程永不结束。apscheduler background定时器守护线程需要这样保持定时器不退出。
+
 
 ```
 
@@ -595,14 +658,17 @@ python比其他语言更需要分布式函数调度框架来执行函数，有
 
 ## 1.6 funboost支持支持celery框架整体作为funboost的broker (2023.4新增)
 ```
-见11.1章节代码例子，celery框架整体作为funboost的broker，funboost的发布和消费将只作为极简api，核心的消费调度和发布和定时功能，都是由celery框架来完成，funboost框架的发布和调度代码不实际起作用。
+见11.1章节代码例子，celery框架整体作为funboost的broker，funboost的发布和消费将只作为极简api，
+核心的消费调度和发布和定时功能，都是由celery框架来完成，funboost框架的发布和调度代码不实际起作用。
 用户操作funboost的api，语法和使用其他消息队列中间件类型一样，funboost自动化操作celery。
 
 用户无需操作celery本身，无需敲击celery难记的命令行启动消费、定时、flower;
 用户无需小心翼翼纠结亲自使用celery时候怎么规划目录结构 文件夹命名 需要怎么在配置写include 写task_routes，
-完全不存在需要固定的celery目录结构，不需要手动配置懵逼的任务路由，不需要配置每个函数怎么使用不同的队列名字，funboost自动搞定这些。
+完全不存在需要固定的celery目录结构，不需要手动配置懵逼的任务路由，
+不需要配置每个函数怎么使用不同的队列名字，funboost自动搞定这些。
 
-用户只需要使用简单的funboost语法就能操控celery框架了。funboost使用celery作为broker_kind,远远的暴击亲自使用无法ide下代码补全的celery框架的语法。
+用户只需要使用简单的funboost语法就能操控celery框架了。funboost使用celery作为broker_kind,
+远远的暴击亲自使用无法ide下代码补全的celery框架的语法。
 ```
 
 ```

{funboost-49.2 → funboost-49.3}/README.md

@@ -39,8 +39,10 @@ Broker。funboost源码高扩展性的设计，造成“万物皆可为Broker”
 框架对代码没有入侵,可以加到任意已有项目而对项目python文件目录结构0要求,
 不像 celery django scrapy 这样的框架,要从一开始就开始规划好项目目录结构,如果不想用框架了,
 或者想改变使用其他框架框架,那么已经所写的代码组织形式就几乎成了废物,需要大改特改. 
-但是funboost完全不会这样,加上或去掉@boost装饰器,对你的项目影响为0,用户照常使用,
+但是funboost完全不会这样,就算是加上或去掉@boost装饰器,对你的项目影响为0,用户照常使用,
 所以用户可以对任意项目,任意时候,引入使用funboost或者去掉使用funboost,代码组织形式不需要发生变化.
+（即使不想用funboost了，也不需要亲自去掉@boost装饰器，因为函数有@boost装饰器对函数自身的直接调用运行没有任何影响，
+用户照样可以直接例如 fun(x,y)是直接运行函数 ， fun.push(x,y) 才是发送到消息队列）
 
 通过funboost web manager 管理系统，支持全面 查看 监控 管理 funboost的任务消费。
 </pre>
@@ -452,26 +454,32 @@ if __name__ == "__main__":
 
 
 
-## 1.3.2 funboost丝滑连续启动多个函数消费
+## 1.3.2 funboost集中演示一个功能更多的综合例子
 
 ```python
 
+
 """
-此代码
-1.演示支持多个函数消费队列的无阻塞启动（consume不会阻塞主线程）
-2.演示支持在一个消费函数内部向任意队列发布新任务，实现多级任务链
-代码结构清晰，扩展性极强
+一个展示更全面 funboost 用法的例子
+包含了
+1.继承BoosterParams，为了每个装饰器少写入参
+2.rpc获取结果
+3.连续丝滑启动多个消费函数
+4.定时任务
 """
-from funboost import boost, BrokerEnum,BoosterParams,ctrl_c_recv,ConcurrentModeEnum
+from funboost import boost, BrokerEnum,BoosterParams,ctrl_c_recv,ConcurrentModeEnum,ApsJobAdder
 import time
 
 class MyBoosterParams(BoosterParams):  # 自定义的参数类，继承BoosterParams，用于减少每个消费函数装饰器的重复相同入参个数
-    broker_kind: str = BrokerEnum.MEMORY_QUEUE
+    broker_kind: str = BrokerEnum.REDIS_ACK_ABLE
     max_retry_times: int = 3
     concurrent_mode: str = ConcurrentModeEnum.THREADING 
 
     
-@boost(MyBoosterParams(queue_name='s1_queue', qps=1, ))
+@boost(MyBoosterParams(queue_name='s1_queue', qps=1, 
+                    #    do_task_filtering=True, # 可开启任务过滤，防止重复入参消费。
+                       is_using_rpc_mode=True, # 开启rpc模式，支持rpc获取结果
+                       ))
 def step1(a:int,b:int):
     print(f'a={a},b={b}')
     time.sleep(0.7)
@@ -480,20 +488,75 @@ def step1(a:int,b:int):
     return a+b
 
 
-@boost(MyBoosterParams(queue_name='s2_queue', qps=3, ))
-def step2(c:int,d:int,e:int):
+@boost(MyBoosterParams(queue_name='s2_queue', qps=3, 
+                      max_retry_times=5，# 可以在此覆盖MyBoosterParams中的默认值，例如为step2单独设置最大重试次数为5
+)) 
+def step2(c:int,d:int,e:int=666):
     time.sleep(3)
     print(f'c={c},d={d},e={e}')
     return c* d * e
 
 
 if __name__ == '__main__':
-    for i in range(100):
-        step1.push(i,i*2) # 向 step1函数的队列发送消息。
+    step1.clear() # 清空队列
+    step2.clear() # 清空队列
+
     step1.consume() # 调用.consume是非阻塞的启动消费，是在单独的子线程中循环拉取消息的。 
     # 有的人还担心阻塞而手动使用 threading.Thread(target=step1.consume).start() 来启动消费，这是完全多此一举的错误写法。
-    step2.consume() # 所以可以连续无阻塞丝滑的启动多个函数消费。
-    ctrl_c_recv()
+    step2.consume() # 所以可以在当前主线程连续无阻塞丝滑的启动多个函数消费。
+    step2.multi_process_consume(3) # 这是多进程叠加了多线程消费，另外开启了3个进程，叠加了默认的线程并发。
+
+    async_result = step1.push(100,b=200)
+    print('step1的rpc结果是：',async_result.result)  # rpc阻塞等待消step1的费结果返回
+
+    for i in range(100):
+        step1.push(i,i*2) # 向 step1函数的队列发送消息,入参和手动调用函数那样很相似。
+        step1.publish ({'a':i,'b':i*2},task_id=f'task_{i}') # publish 第一个入参是字典，比push能传递更多funboost的辅助参数，类似celery的apply_async和delay的关系。一个简单，一个复杂但强大。
+    
+    
+
+    """
+    1.funboost 使用 ApsJobAdder.add_push_job来添加定时任务，不是add_job。
+    2.funboost是轻度封装的知名apscheduler框架，所以定时任务的语法和apscheduler是一样的，没有自己发明语法和入参
+    用户需要苦学apscheduler教程，一切定时都是要学apscheduler知识，定时和funboost知识关系很小。
+    3.funboost的定时任务目的是定时推送消息到消息队列中，而不是定时直接在当前程序中执行某个消费函数。
+
+    下面是三种方式添加定时任务，这些定时方式都是知名apscheduler包的定时方式，和funboost没关系。
+    """
+    # 方式1：指定日期执行一次
+    ApsJobAdder(step2, 
+               job_store_kind='redis', # 使用reids作为 apscheduler的 jobstrores
+               is_auto_start=True,   # 添加任务，并同时顺便启动了定时器 执行了apscheduler对象.start()
+    ).add_push_job(
+        trigger='date',
+        run_date='2025-06-30 16:25:40',
+        args=(7, 8,9),
+        id='date_job1',
+        replace_existing=True,
+    )
+
+    # 方式2：固定间隔执行
+    ApsJobAdder(step2, job_store_kind='redis').add_push_job(
+        trigger='interval',
+        seconds=30,
+        args=(4, 6,10),
+        id='interval_job1',
+        replace_existing=True,
+    )
+
+    # 方式3：使用cron表达式定时执行
+    ApsJobAdder(step2, job_store_kind='redis').add_push_job(
+        trigger='cron',
+        day_of_week='*',
+        hour=23,
+        minute=49,
+        second=50,
+        kwargs={"c": 50, "d": 60,"e":70},
+        replace_existing=True,
+        id='cron_job1')
+    
+    ctrl_c_recv()  # 用于阻塞代码，阻止主线程退出，使主线程永久运行。  相当于 你在代码最末尾，加了个 while 1:time.sleep(10)，使主线程永不结束。apscheduler background定时器守护线程需要这样保持定时器不退出。
+
 
 ```
 
@@ -561,14 +624,17 @@ python比其他语言更需要分布式函数调度框架来执行函数，有
 
 ## 1.6 funboost支持支持celery框架整体作为funboost的broker (2023.4新增)
 ```
-见11.1章节代码例子，celery框架整体作为funboost的broker，funboost的发布和消费将只作为极简api，核心的消费调度和发布和定时功能，都是由celery框架来完成，funboost框架的发布和调度代码不实际起作用。
+见11.1章节代码例子，celery框架整体作为funboost的broker，funboost的发布和消费将只作为极简api，
+核心的消费调度和发布和定时功能，都是由celery框架来完成，funboost框架的发布和调度代码不实际起作用。
 用户操作funboost的api，语法和使用其他消息队列中间件类型一样，funboost自动化操作celery。
 
 用户无需操作celery本身，无需敲击celery难记的命令行启动消费、定时、flower;
 用户无需小心翼翼纠结亲自使用celery时候怎么规划目录结构 文件夹命名 需要怎么在配置写include 写task_routes，
-完全不存在需要固定的celery目录结构，不需要手动配置懵逼的任务路由，不需要配置每个函数怎么使用不同的队列名字，funboost自动搞定这些。
+完全不存在需要固定的celery目录结构，不需要手动配置懵逼的任务路由，
+不需要配置每个函数怎么使用不同的队列名字，funboost自动搞定这些。
 
-用户只需要使用简单的funboost语法就能操控celery框架了。funboost使用celery作为broker_kind,远远的暴击亲自使用无法ide下代码补全的celery框架的语法。
+用户只需要使用简单的funboost语法就能操控celery框架了。funboost使用celery作为broker_kind,
+远远的暴击亲自使用无法ide下代码补全的celery框架的语法。
 ```
 
 ```

{funboost-49.2 → funboost-49.3}/funboost/__init__.py

@@ -13,7 +13,7 @@ set_frame_config这个模块的 use_config_form_funboost_config_module() 是核
 这段注释说明和使用的用户无关,只和框架开发人员有关.
 '''
 
-__version__ = "49.2"
+__version__ = "49.3"
 
 from funboost.set_frame_config import show_frame_config
 

{funboost-49.2 → funboost-49.3}/funboost/concurrent_pool/async_pool_executor.py

@@ -48,7 +48,7 @@ if sys.platform == "darwin":  # mac 上会出错
       import selectors
       selectors.DefaultSelector = selectors.PollSelector
 
-class AsyncPoolExecutorLtPy310(FunboostFileLoggerMixin,FunboostBaseConcurrentPool):
+class AsyncPoolExecutor(FunboostFileLoggerMixin,FunboostBaseConcurrentPool):
     """
     使api和线程池一样，最好的性能做法是submit也弄成 async def，生产和消费在同一个线程同一个loop一起运行，但会对调用链路的兼容性产生破坏，从而调用方式不兼容线程池。
     """
@@ -80,8 +80,12 @@ class AsyncPoolExecutorLtPy310(FunboostFileLoggerMixin,FunboostBaseConcurrentPoo
     #                 time.sleep(0.01)
 
     def _diff_init(self):
-        self._sem = asyncio.Semaphore(self._size, loop=self.loop)
-        self._queue = asyncio.Queue(maxsize=self._size, loop=self.loop)
+        if sys.version_info.minor < 10:
+            # self._sem = asyncio.Semaphore(self._size, loop=self.loop)
+            self._queue = asyncio.Queue(maxsize=self._size, loop=self.loop)
+        else:
+            # self._sem = asyncio.Semaphore(self._size) # python3.10后，很多类和方法都删除了loop传参
+            self._queue = asyncio.Queue(maxsize=self._size)
 
 
     def submit(self, func, *args, **kwargs):
@@ -101,7 +105,7 @@ class AsyncPoolExecutorLtPy310(FunboostFileLoggerMixin,FunboostBaseConcurrentPoo
             try:
                 await func(*args, **kwargs)
             except BaseException as e:
-                traceback.print_exc()
+                self.logger.exception(f'func:{func}, args:{args}, kwargs:{kwargs} exc_type:{type(e)}  traceback_exc:{traceback.format_exc()}')
             # self._queue.task_done()
 
     async def __run(self):
@@ -135,17 +139,11 @@ class AsyncPoolExecutorLtPy310(FunboostFileLoggerMixin,FunboostBaseConcurrentPoo
 
 
 
-class AsyncPoolExecutorGtPy310(AsyncPoolExecutorLtPy310):
-
-    def _diff_init(self):
-        self._sem = asyncio.Semaphore(self._size, ) # python3.10后，很多类和方法都删除了loop传参
-        self._queue = asyncio.Queue(maxsize=self._size, )
 
 
 
 
 
-AsyncPoolExecutor = AsyncPoolExecutorLtPy310 if sys.version_info.minor < 10 else AsyncPoolExecutorGtPy310
 
 
 

{funboost-49.2 → funboost-49.3}/funboost/consumers/rocketmq_consumer.py

@@ -22,12 +22,12 @@ class RocketmqConsumer(AbstractConsumer):
         except BaseException as e:
             # print(traceback.format_exc())
             raise ImportError(f'rocketmq包 只支持linux和mac {e}')
-        consumer = PushConsumer(self.GROUP_ID)
+        consumer = PushConsumer(f'{self.GROUP_ID}_{self._queue_name}')
         consumer.set_namesrv_addr(BrokerConnConfig.ROCKETMQ_NAMESRV_ADDR)
         consumer.set_thread_count(1)
         consumer.set_message_batch_max_size(self.consumer_params.concurrent_num)
 
-        self._publisher = RocketmqPublisher(publisher_params=PublisherParams(queue_name=self._queue_name))
+        self._publisher = RocketmqPublisher(publisher_params=PublisherParams(queue_name=self._queue_name,))
 
         def callback(rocketmq_msg):
             # self.logger.debug(f'从rocketmq的 [{self._queue_name}] 主题的queue_id {rocketmq_msg.queue_id} 中 取出的消息是：{rocketmq_msg.body}')

{funboost-49.2 → funboost-49.3}/funboost/publishers/redis_publisher_priority.py

@@ -28,7 +28,7 @@ class RedisPriorityPublisher(FlushRedisQueueMixin,AbstractPublisher, RedisMixin,
         :return:
         """
         priority = self._get_from_other_extra_params('priroty', msg)
-        x_max_priority = self.publisher_params.broker_exclusive_config('x-max-priority')
+        x_max_priority = self.publisher_params.broker_exclusive_config['x-max-priority']
         queue_name = self.queue_name
         if x_max_priority and priority:
             priority = min(priority, x_max_priority)  # 防止有傻瓜发布消息的优先级priroty比最大支持的优先级还高。

{funboost-49.2 → funboost-49.3/funboost.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: funboost
-Version: 49.2
+Version: 49.3
 Summary: pip install funboost，python全功能分布式函数调度框架,funboost的功能是全面性重量级，用户能想得到的功能99%全都有;funboost的使用方式是轻量级，只有@boost一行代码需要写。支持python所有类型的并发模式和一切知名消息队列中间件，支持如 celery dramatiq等框架整体作为funboost中间件，python函数加速器，框架包罗万象，用户能想到的控制功能全都有。一统编程思维，兼容50% python业务场景，适用范围广。只需要一行代码即可分布式执行python一切函数，funboost web manager 方便查看和管理消费函数；99%用过funboost的pythoner 感受是　简易 方便 强劲 强大，相见恨晚 
 Home-page: https://github.com/ydf0509/funboost
 Author: bfzs
@@ -73,8 +73,10 @@ Broker。funboost源码高扩展性的设计，造成“万物皆可为Broker”
 框架对代码没有入侵,可以加到任意已有项目而对项目python文件目录结构0要求,
 不像 celery django scrapy 这样的框架,要从一开始就开始规划好项目目录结构,如果不想用框架了,
 或者想改变使用其他框架框架,那么已经所写的代码组织形式就几乎成了废物,需要大改特改. 
-但是funboost完全不会这样,加上或去掉@boost装饰器,对你的项目影响为0,用户照常使用,
+但是funboost完全不会这样,就算是加上或去掉@boost装饰器,对你的项目影响为0,用户照常使用,
 所以用户可以对任意项目,任意时候,引入使用funboost或者去掉使用funboost,代码组织形式不需要发生变化.
+（即使不想用funboost了，也不需要亲自去掉@boost装饰器，因为函数有@boost装饰器对函数自身的直接调用运行没有任何影响，
+用户照样可以直接例如 fun(x,y)是直接运行函数 ， fun.push(x,y) 才是发送到消息队列）
 
 通过funboost web manager 管理系统，支持全面 查看 监控 管理 funboost的任务消费。
 </pre>
@@ -486,26 +488,32 @@ if __name__ == "__main__":
 
 
 
-## 1.3.2 funboost丝滑连续启动多个函数消费
+## 1.3.2 funboost集中演示一个功能更多的综合例子
 
 ```python
 
+
 """
-此代码
-1.演示支持多个函数消费队列的无阻塞启动（consume不会阻塞主线程）
-2.演示支持在一个消费函数内部向任意队列发布新任务，实现多级任务链
-代码结构清晰，扩展性极强
+一个展示更全面 funboost 用法的例子
+包含了
+1.继承BoosterParams，为了每个装饰器少写入参
+2.rpc获取结果
+3.连续丝滑启动多个消费函数
+4.定时任务
 """
-from funboost import boost, BrokerEnum,BoosterParams,ctrl_c_recv,ConcurrentModeEnum
+from funboost import boost, BrokerEnum,BoosterParams,ctrl_c_recv,ConcurrentModeEnum,ApsJobAdder
 import time
 
 class MyBoosterParams(BoosterParams):  # 自定义的参数类，继承BoosterParams，用于减少每个消费函数装饰器的重复相同入参个数
-    broker_kind: str = BrokerEnum.MEMORY_QUEUE
+    broker_kind: str = BrokerEnum.REDIS_ACK_ABLE
     max_retry_times: int = 3
     concurrent_mode: str = ConcurrentModeEnum.THREADING 
 
     
-@boost(MyBoosterParams(queue_name='s1_queue', qps=1, ))
+@boost(MyBoosterParams(queue_name='s1_queue', qps=1, 
+                    #    do_task_filtering=True, # 可开启任务过滤，防止重复入参消费。
+                       is_using_rpc_mode=True, # 开启rpc模式，支持rpc获取结果
+                       ))
 def step1(a:int,b:int):
     print(f'a={a},b={b}')
     time.sleep(0.7)
@@ -514,20 +522,75 @@ def step1(a:int,b:int):
     return a+b
 
 
-@boost(MyBoosterParams(queue_name='s2_queue', qps=3, ))
-def step2(c:int,d:int,e:int):
+@boost(MyBoosterParams(queue_name='s2_queue', qps=3, 
+                      max_retry_times=5，# 可以在此覆盖MyBoosterParams中的默认值，例如为step2单独设置最大重试次数为5
+)) 
+def step2(c:int,d:int,e:int=666):
     time.sleep(3)
     print(f'c={c},d={d},e={e}')
     return c* d * e
 
 
 if __name__ == '__main__':
-    for i in range(100):
-        step1.push(i,i*2) # 向 step1函数的队列发送消息。
+    step1.clear() # 清空队列
+    step2.clear() # 清空队列
+
     step1.consume() # 调用.consume是非阻塞的启动消费，是在单独的子线程中循环拉取消息的。 
     # 有的人还担心阻塞而手动使用 threading.Thread(target=step1.consume).start() 来启动消费，这是完全多此一举的错误写法。
-    step2.consume() # 所以可以连续无阻塞丝滑的启动多个函数消费。
-    ctrl_c_recv()
+    step2.consume() # 所以可以在当前主线程连续无阻塞丝滑的启动多个函数消费。
+    step2.multi_process_consume(3) # 这是多进程叠加了多线程消费，另外开启了3个进程，叠加了默认的线程并发。
+
+    async_result = step1.push(100,b=200)
+    print('step1的rpc结果是：',async_result.result)  # rpc阻塞等待消step1的费结果返回
+
+    for i in range(100):
+        step1.push(i,i*2) # 向 step1函数的队列发送消息,入参和手动调用函数那样很相似。
+        step1.publish ({'a':i,'b':i*2},task_id=f'task_{i}') # publish 第一个入参是字典，比push能传递更多funboost的辅助参数，类似celery的apply_async和delay的关系。一个简单，一个复杂但强大。
+    
+    
+
+    """
+    1.funboost 使用 ApsJobAdder.add_push_job来添加定时任务，不是add_job。
+    2.funboost是轻度封装的知名apscheduler框架，所以定时任务的语法和apscheduler是一样的，没有自己发明语法和入参
+    用户需要苦学apscheduler教程，一切定时都是要学apscheduler知识，定时和funboost知识关系很小。
+    3.funboost的定时任务目的是定时推送消息到消息队列中，而不是定时直接在当前程序中执行某个消费函数。
+
+    下面是三种方式添加定时任务，这些定时方式都是知名apscheduler包的定时方式，和funboost没关系。
+    """
+    # 方式1：指定日期执行一次
+    ApsJobAdder(step2, 
+               job_store_kind='redis', # 使用reids作为 apscheduler的 jobstrores
+               is_auto_start=True,   # 添加任务，并同时顺便启动了定时器 执行了apscheduler对象.start()
+    ).add_push_job(
+        trigger='date',
+        run_date='2025-06-30 16:25:40',
+        args=(7, 8,9),
+        id='date_job1',
+        replace_existing=True,
+    )
+
+    # 方式2：固定间隔执行
+    ApsJobAdder(step2, job_store_kind='redis').add_push_job(
+        trigger='interval',
+        seconds=30,
+        args=(4, 6,10),
+        id='interval_job1',
+        replace_existing=True,
+    )
+
+    # 方式3：使用cron表达式定时执行
+    ApsJobAdder(step2, job_store_kind='redis').add_push_job(
+        trigger='cron',
+        day_of_week='*',
+        hour=23,
+        minute=49,
+        second=50,
+        kwargs={"c": 50, "d": 60,"e":70},
+        replace_existing=True,
+        id='cron_job1')
+    
+    ctrl_c_recv()  # 用于阻塞代码，阻止主线程退出，使主线程永久运行。  相当于 你在代码最末尾，加了个 while 1:time.sleep(10)，使主线程永不结束。apscheduler background定时器守护线程需要这样保持定时器不退出。
+
 
 ```
 
@@ -595,14 +658,17 @@ python比其他语言更需要分布式函数调度框架来执行函数，有
 
 ## 1.6 funboost支持支持celery框架整体作为funboost的broker (2023.4新增)
 ```
-见11.1章节代码例子，celery框架整体作为funboost的broker，funboost的发布和消费将只作为极简api，核心的消费调度和发布和定时功能，都是由celery框架来完成，funboost框架的发布和调度代码不实际起作用。
+见11.1章节代码例子，celery框架整体作为funboost的broker，funboost的发布和消费将只作为极简api，
+核心的消费调度和发布和定时功能，都是由celery框架来完成，funboost框架的发布和调度代码不实际起作用。
 用户操作funboost的api，语法和使用其他消息队列中间件类型一样，funboost自动化操作celery。
 
 用户无需操作celery本身，无需敲击celery难记的命令行启动消费、定时、flower;
 用户无需小心翼翼纠结亲自使用celery时候怎么规划目录结构 文件夹命名 需要怎么在配置写include 写task_routes，
-完全不存在需要固定的celery目录结构，不需要手动配置懵逼的任务路由，不需要配置每个函数怎么使用不同的队列名字，funboost自动搞定这些。
+完全不存在需要固定的celery目录结构，不需要手动配置懵逼的任务路由，
+不需要配置每个函数怎么使用不同的队列名字，funboost自动搞定这些。
 
-用户只需要使用简单的funboost语法就能操控celery框架了。funboost使用celery作为broker_kind,远远的暴击亲自使用无法ide下代码补全的celery框架的语法。
+用户只需要使用简单的funboost语法就能操控celery框架了。funboost使用celery作为broker_kind,
+远远的暴击亲自使用无法ide下代码补全的celery框架的语法。
 ```
 
 ```