funboost 48.9__tar.gz → 49.1__tar.gz

{funboost-48.9/funboost.egg-info → funboost-49.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: funboost
-Version: 48.9
+Version: 49.1
 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
@@ -62,8 +62,8 @@ funboost的神奇之处在于它同时拥有"轻量级使用方式"和"重量级
 python函数加速器，框架包罗万象，一统编程思维，兼容50% python编程业务场景，适用范围广。
 python万能分布式函数调度框架，支持5种并发模式，30+种消息队列中间件
 (不仅支持几乎所有你能想到的消息队列中间件，还支持本地磁盘队列、数据库队列 (SQLAlchemy, Peewee)、
-内存队列、甚至是 HTTP 请求、WebSocket 等作为任务队列，甚至是将 Celery、Dramatiq、Huey 等其他框架整体作为其 Broker。
-funboost源码高扩展性的设计，造成“万物皆可为Broker”,并不是有30种传统意义上的经典消息队列，
+内存队列、甚至是 HTTP 请求、WebSocket 等作为任务队列，甚至是将 Celery、Dramatiq、Huey 等其他框架整体作为其
+Broker。funboost源码高扩展性的设计，造成“万物皆可为Broker”,并不是有30种传统意义上的经典消息队列，
 因为世界上总共都没有30种知名的经典消息队列)，
 30种任务控制功能。给任意python函数赋能。
 用途概念就是常规经典的 生产者 + 消息队列中间件 + 消费者 编程思想。
@@ -543,15 +543,21 @@ if __name__ == '__main__':
 
 
 队列操作：查看和操作队列，包括 清空清空 暂停消费 恢复消费 调整qps和并发
-[![pEJC6m9.png](https://s21.ax1x.com/2025/03/04/pEJC6m9.png)](https://imgse.com/i/pEJC6m9)
+<!-- [![pEJC6m9.png](https://s21.ax1x.com/2025/03/04/pEJC6m9.png)](https://imgse.com/i/pEJC6m9) -->
+[![pVSOJcq.png](https://s21.ax1x.com/2025/05/27/pVSOJcq.png)](https://imgse.com/i/pVSOJcq)
 
 队列操作，查看消费者详情：查看队列的所有消费者详情
 [![pEJCgT1.png](https://s21.ax1x.com/2025/03/04/pEJCgT1.png)](https://imgse.com/i/pEJCgT1)
 
+队列操作:查看消费曲线图，查看各种消费指标。
+[![pVpr7sP.png](https://s21.ax1x.com/2025/05/29/pVpr7sP.png)](https://imgse.com/i/pVpr7sP)
+
 rpc调用：在网页上对30种消息队列发布消息并获取消息的函数执行结；根据taskid获取结果。
 <!-- [![pETq8hj.png](https://s21.ax1x.com/2025/04/28/pETq8hj.png)](https://imgse.com/i/pETq8hj) -->
 [![pE7y8oT.png](https://s21.ax1x.com/2025/04/29/pE7y8oT.png)](https://imgse.com/i/pE7y8oT)
 
+
+
 ## 1.4  python分布式函数执行为什么重要？
 
 ```text

{funboost-48.9 → funboost-49.1}/README.md

@@ -1,5 +1,5 @@
 ---
-noteId: "accb16103c5611f09da1a79051113d13"
+noteId: "67d3a8f045e411f0ab0bf59d9f569ed4"
 tags: []
 
 ---
@@ -35,8 +35,8 @@ funboost的神奇之处在于它同时拥有"轻量级使用方式"和"重量级
 python函数加速器，框架包罗万象，一统编程思维，兼容50% python编程业务场景，适用范围广。
 python万能分布式函数调度框架，支持5种并发模式，30+种消息队列中间件
 (不仅支持几乎所有你能想到的消息队列中间件，还支持本地磁盘队列、数据库队列 (SQLAlchemy, Peewee)、
-内存队列、甚至是 HTTP 请求、WebSocket 等作为任务队列，甚至是将 Celery、Dramatiq、Huey 等其他框架整体作为其 Broker。
-funboost源码高扩展性的设计，造成“万物皆可为Broker”,并不是有30种传统意义上的经典消息队列，
+内存队列、甚至是 HTTP 请求、WebSocket 等作为任务队列，甚至是将 Celery、Dramatiq、Huey 等其他框架整体作为其
+Broker。funboost源码高扩展性的设计，造成“万物皆可为Broker”,并不是有30种传统意义上的经典消息队列，
 因为世界上总共都没有30种知名的经典消息队列)，
 30种任务控制功能。给任意python函数赋能。
 用途概念就是常规经典的 生产者 + 消息队列中间件 + 消费者 编程思想。
@@ -516,15 +516,21 @@ if __name__ == '__main__':
 
 
 队列操作：查看和操作队列，包括 清空清空 暂停消费 恢复消费 调整qps和并发
-[![pEJC6m9.png](https://s21.ax1x.com/2025/03/04/pEJC6m9.png)](https://imgse.com/i/pEJC6m9)
+<!-- [![pEJC6m9.png](https://s21.ax1x.com/2025/03/04/pEJC6m9.png)](https://imgse.com/i/pEJC6m9) -->
+[![pVSOJcq.png](https://s21.ax1x.com/2025/05/27/pVSOJcq.png)](https://imgse.com/i/pVSOJcq)
 
 队列操作，查看消费者详情：查看队列的所有消费者详情
 [![pEJCgT1.png](https://s21.ax1x.com/2025/03/04/pEJCgT1.png)](https://imgse.com/i/pEJCgT1)
 
+队列操作:查看消费曲线图，查看各种消费指标。
+[![pVpr7sP.png](https://s21.ax1x.com/2025/05/29/pVpr7sP.png)](https://imgse.com/i/pVpr7sP)
+
 rpc调用：在网页上对30种消息队列发布消息并获取消息的函数执行结；根据taskid获取结果。
 <!-- [![pETq8hj.png](https://s21.ax1x.com/2025/04/28/pETq8hj.png)](https://imgse.com/i/pETq8hj) -->
 [![pE7y8oT.png](https://s21.ax1x.com/2025/04/29/pE7y8oT.png)](https://imgse.com/i/pE7y8oT)
 
+
+
 ## 1.4  python分布式函数执行为什么重要？
 
 ```text

{funboost-48.9 → funboost-49.1}/funboost/__init__.py

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

{funboost-48.9 → funboost-49.1}/funboost/consumers/base_consumer.py

@@ -480,9 +480,9 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
             return
         function_only_params = delete_keys_and_return_new_dict(kw['body'], )
         if self._get_priority_conf(kw, 'do_task_filtering') and self._redis_filter.check_value_exists(
-                function_only_params):  # 对函数的参数进行检查，过滤已经执行过并且成功的任务。
+                function_only_params,self._get_priority_conf(kw, 'filter_str')):  # 对函数的参数进行检查，过滤已经执行过并且成功的任务。
             self.logger.warning(f'redis的 [{self._redis_filter_key_name}] 键 中 过滤任务 {kw["body"]}')
-            self._confirm_consume(kw)
+            self._confirm_consume(kw) # 不运行就必须确认消费，否则会发不能确认消费，导致消息队列中间件认为消息没有被消费。
             return
         publish_time = get_publish_time(kw['body'])
         msg_expire_senconds_priority = self._get_priority_conf(kw, 'msg_expire_senconds')
@@ -678,7 +678,7 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
             current_function_result_status.run_status = RunStatus.finish
             self._result_persistence_helper.save_function_result_to_mongo(current_function_result_status)
             if self._get_priority_conf(kw, 'do_task_filtering'):
-                self._redis_filter.add_a_value(function_only_params)  # 函数执行成功后，添加函数的参数排序后的键值对字符串到set中。
+                self._redis_filter.add_a_value(function_only_params,self._get_priority_conf(kw, 'filter_str'))  # 函数执行成功后，添加函数的参数排序后的键值对字符串到set中。
             if current_function_result_status.success is False and current_retry_times == max_retry_times:
                 log_msg = f'函数 {self.consuming_function.__name__} 达到最大重试次数 {self._get_priority_conf(kw, "max_retry_times")} 后,仍然失败， 入参是  {function_only_params} '
                 if self.consumer_params.is_push_to_dlx_queue_when_retry_max_times:
@@ -832,7 +832,7 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
             await simple_run_in_executor(self._result_persistence_helper.save_function_result_to_mongo, current_function_result_status)
             if self._get_priority_conf(kw, 'do_task_filtering'):
                 # self._redis_filter.add_a_value(function_only_params)  # 函数执行成功后，添加函数的参数排序后的键值对字符串到set中。
-                await simple_run_in_executor(self._redis_filter.add_a_value, function_only_params)
+                await simple_run_in_executor(self._redis_filter.add_a_value, function_only_params,self._get_priority_conf(kw, 'filter_str'))
             if current_function_result_status.success is False and current_retry_times == max_retry_times:
                 log_msg = f'函数 {self.consuming_function.__name__} 达到最大重试次数 {self._get_priority_conf(kw, "max_retry_times")} 后,仍然失败， 入参是  {function_only_params} '
                 if self.consumer_params.is_push_to_dlx_queue_when_retry_max_times:

{funboost-48.9 → funboost-49.1}/funboost/consumers/redis_filter.py

@@ -32,23 +32,36 @@ class RedisFilter(RedisMixin, FunboostFileLoggerMixin):
         self._redis_key_name = redis_key_name
         self._redis_filter_task_expire_seconds = redis_filter_task_expire_seconds
 
+        # @staticmethod
+        # def _get_ordered_str(value):
+        #     """对json的键值对在redis中进行过滤，需要先把键值对排序，否则过滤会不准确如 {"a":1,"b":2} 和 {"b":2,"a":1}"""
+        #     value = Serialization.to_dict(value)
+        #     ordered_dict = OrderedDict()
+        #     for k in sorted(value):
+        #         ordered_dict[k] = value[k]
+        #     return json.dumps(ordered_dict)
+    
     @staticmethod
-    def _get_ordered_str(value):
+    def generate_filter_str(value: typing.Union[str, dict],  filter_str: typing.Optional[str] = None):
         """对json的键值对在redis中进行过滤，需要先把键值对排序，否则过滤会不准确如 {"a":1,"b":2} 和 {"b":2,"a":1}"""
+        if filter_str: # 如果用户单独指定了过滤字符串，就使用使用户指定的过滤字符串，否则使用排序后的键值对字符串
+            return filter_str
         value = Serialization.to_dict(value)
         ordered_dict = OrderedDict()
         for k in sorted(value):
             ordered_dict[k] = value[k]
+        # print(ordered_dict,filter_str)
         return json.dumps(ordered_dict)
 
-    def add_a_value(self, value: typing.Union[str, dict]):
-        self.redis_db_filter_and_rpc_result.sadd(self._redis_key_name, self._get_ordered_str(value))
 
-    def manual_delete_a_value(self, value: typing.Union[str, dict]):
-        self.redis_db_filter_and_rpc_result.srem(self._redis_key_name, self._get_ordered_str(value))
+    def add_a_value(self, value: typing.Union[str, dict], filter_str: typing.Optional[str] = None):
+        self.redis_db_filter_and_rpc_result.sadd(self._redis_key_name, self.generate_filter_str(value, filter_str))
 
-    def check_value_exists(self, value):
-        return self.redis_db_filter_and_rpc_result.sismember(self._redis_key_name, self._get_ordered_str(value))
+    def manual_delete_a_value(self, value: typing.Union[str, dict], filter_str: typing.Optional[str] = None):
+        self.redis_db_filter_and_rpc_result.srem(self._redis_key_name, self.generate_filter_str(value, filter_str))
+
+    def check_value_exists(self, value, filter_str: typing.Optional[str] = None):
+        return self.redis_db_filter_and_rpc_result.sismember(self._redis_key_name, self.generate_filter_str(value, filter_str))
 
     def delete_expire_filter_task_cycle(self):
         pass
@@ -61,15 +74,17 @@ class RedisImpermanencyFilter(RedisFilter):
     如果是30分钟内发布过这个任务，则不执行1 + 2，现在把这个逻辑集成到框架，一般用于接口缓存。
     """
 
-    def add_a_value(self, value: typing.Union[str, dict]):
-        self.redis_db_filter_and_rpc_result.zadd(self._redis_key_name, {self._get_ordered_str(value):time.time()})
+    def add_a_value(self, value: typing.Union[str, dict], filter_str: typing.Optional[str] = None):
+        self.redis_db_filter_and_rpc_result.zadd(self._redis_key_name, {self.generate_filter_str(value, filter_str):time.time()})
 
-    def manual_delete_a_value(self, value: typing.Union[str, dict]):
-        self.redis_db_filter_and_rpc_result.zrem(self._redis_key_name, self._get_ordered_str(value))
+    def manual_delete_a_value(self, value: typing.Union[str, dict], filter_str: typing.Optional[str] = None):
+        self.redis_db_filter_and_rpc_result.zrem(self._redis_key_name, self.generate_filter_str(value, filter_str))
 
-    def check_value_exists(self, value):
-        # print(self.redis_db_filter_and_rpc_result.zrank(self._redis_key_name, self._get_ordered_str(value)))
-        return False if self.redis_db_filter_and_rpc_result.zrank(self._redis_key_name, self._get_ordered_str(value)) is None else True
+    def check_value_exists(self, value, filter_str: typing.Optional[str] = None):
+        # print(self.redis_db_filter_and_rpc_result.zrank(self._redis_key_name, self.generate_filter_str(value, filter_str)))
+        is_exists = False if self.redis_db_filter_and_rpc_result.zscore(self._redis_key_name, self.generate_filter_str(value, filter_str)) is None else True
+        # print(is_exists,value,filter_str,self.generate_filter_str(value, filter_str))
+        return is_exists   
 
     @decorators.keep_circulating(60, block=False)
     def delete_expire_filter_task_cycle000(self):
@@ -111,16 +126,16 @@ class RedisImpermanencyFilterUsingRedisKey(RedisFilter):
         """
         return f'{self._redis_key_name}:{value.replace(":", "：")}'  # 任务是json，带有：会形成很多树，换成中文冒号。
 
-    def add_a_value(self, value: typing.Union[str, dict]):
-        redis_key = self.__add_dir_prefix(self._get_ordered_str(value))
+    def add_a_value(self, value: typing.Union[str, dict], filter_str: typing.Optional[str] = None):
+        redis_key = self.__add_dir_prefix(self.generate_filter_str(value, filter_str))
         self.redis_db_filter_and_rpc_result.set(redis_key, 1)
         self.redis_db_filter_and_rpc_result.expire(redis_key, self._redis_filter_task_expire_seconds)
 
-    def manual_delete_a_value(self, value: typing.Union[str, dict]):
-        self.redis_db_filter_and_rpc_result.delete(self.__add_dir_prefix(self._get_ordered_str(value)))
+    def manual_delete_a_value(self, value: typing.Union[str, dict], filter_str: typing.Optional[str] = None):
+        self.redis_db_filter_and_rpc_result.delete(self.__add_dir_prefix(self.generate_filter_str(value, filter_str)))
 
-    def check_value_exists(self, value):
-        return True if self.redis_db_filter_and_rpc_result.exists(self.__add_dir_prefix(self._get_ordered_str(value))) else True
+    def check_value_exists(self, value, filter_str: typing.Optional[str] = None):
+        return True if self.redis_db_filter_and_rpc_result.exists(self.__add_dir_prefix(self.generate_filter_str(value, filter_str))) else True
 
     def delete_expire_filter_task_cycle(self):
         """
@@ -131,16 +146,17 @@ class RedisImpermanencyFilterUsingRedisKey(RedisFilter):
 
 
 if __name__ == '__main__':
-    # filter = RedisFilter('filter_set:abcdefgh', 120)
-    params_filter = RedisImpermanencyFilter('filter_zset:abcdef', 120)
+    # params_filter = RedisFilter('filter_set:abcdefgh2', 120)
+    params_filter = RedisImpermanencyFilter('filter_zset:abcdef2', 120)
     # params_filter = RedisImpermanencyFilterUsingRedisKey('filter_dir', 300)
     for i in range(10):
-        params_filter.add_a_value({'x': i, 'y': i * 2})
-
-    params_filter.manual_delete_a_value({'a': 1, 'b': 2})
-    print(params_filter.check_value_exists({'a': 1, 'b': 2}))
-    params_filter.delete_expire_filter_task_cycle()
-    params_filter.add_a_value({'a': 1, 'b': 5})
-    print(params_filter.check_value_exists({'a': 1, 'b': 2}))
-    time.sleep(130)
-    print(params_filter.check_value_exists({'a': 1, 'b': 2}))
+        # params_filter.add_a_value({'x': i, 'y': i * 2},str(i))
+        params_filter.add_a_value({'x': i, 'y': i * 2},None)
+
+    # params_filter.manual_delete_a_value({'a': 1, 'b': 2})
+    print(params_filter.check_value_exists({'x': 1, 'y': 2}))
+    # params_filter.delete_expire_filter_task_cycle()
+    # params_filter.add_a_value({'a': 1, 'b': 5})
+    # print(params_filter.check_value_exists({'a': 1, 'b': 2}))
+    # time.sleep(130)
+    # print(params_filter.check_value_exists({'a': 1, 'b': 2}))

{funboost-48.9 → funboost-49.1}/funboost/core/func_params_model.py

@@ -308,6 +308,15 @@ class PriorityConsumingControlConfig(BaseJsonAbleModel):
     misfire_grace_time: typing.Union[int, None] = None
 
     other_extra_params: dict = None  # 其他参数, 例如消息优先级 , priority_control_config=PriorityConsumingControlConfig(other_extra_params={'priroty': priorityxx})，
+    
+    """filter_str:
+    用户指定过滤字符串， 例如函数入参是 def fun(userid,username,sex，user_description),
+    默认是所有入参一起组成json来过滤，但其实只把userid的值来过滤就好了。所以如果需要精准的按照什么过滤，用户来灵活指定一个字符串就好了
+    
+    用法见文档4.35 
+    f3.publish(msg={'a':i,'b':i*2},priority_control_config=PriorityConsumingControlConfig(filter_str=str(i)))
+    """
+    filter_str :typing.Optional[str] = None 
 
     @root_validator(skip_on_failure=True)
     def cehck_values(cls, values: dict):

{funboost-48.9 → funboost-49.1}/funboost/function_result_web/app.py

@@ -221,10 +221,7 @@ def hearbeat_info_partion_by_ip():
 def get_queue_params_and_active_consumers():
     return jsonify(QueueConusmerParamsGetter().get_queue_params_and_active_consumers())
 
-@app.route('/queue/message_count/<broker_kind>/<queue_name>')
-def get_message_count(broker_kind,queue_name):
-    publisher = BoostersManager.get_cross_project_publisher(PublisherParams(queue_name=queue_name, broker_kind=broker_kind, publish_msg_log_use_full_msg=True))
-    return jsonify({'count':publisher.get_message_count(),'success':True})
+
 
 
 @app.route('/queue/clear/<broker_kind>/<queue_name>',methods=['POST'])
@@ -243,9 +240,27 @@ def resume_consume(queue_name):
     RedisMixin().redis_db_frame.hset(RedisKeys.REDIS_KEY_PAUSE_FLAG, queue_name,'0')
     return jsonify({'success':True})
 
-@app.route('/queue/get_msg_num',methods=['GET'])
-def get_msg_num():
+@app.route('/queue/get_msg_num_all_queues',methods=['GET'])
+def get_msg_num_all_queues():
+    """这个是通过消费者周期每隔10秒上报到redis的，性能好。不需要实时获取每个消息队列，直接从redis读取所有队列的消息数量"""
     return jsonify(QueueConusmerParamsGetter().get_msg_num(ignore_report_ts=True))
+
+@app.route('/queue/message_count/<broker_kind>/<queue_name>')
+def get_message_count(broker_kind,queue_name):
+    """这个是实时获取每个消息队列的消息数量，性能差，但是可以实时获取每个消息队列的消息数量"""
+    queue_params = QueueConusmerParamsGetter().get_queue_params()
+    for queue_namex,params in queue_params.items():
+        if params['broker_kind'] == broker_kind and queue_namex == queue_name:
+            publisher = BoostersManager.get_cross_project_publisher(
+                PublisherParams(queue_name=queue_name, 
+                                 broker_kind=broker_kind,
+                                 broker_exclusive_config=params['broker_exclusive_config'],
+                                 publish_msg_log_use_full_msg=True))
+            return jsonify({'count':publisher.get_message_count(),'success':True})
+    return jsonify({'success':False,'msg':f'队列{queue_name}不存在'})
+
+    publisher = BoostersManager.get_cross_project_publisher(PublisherParams(queue_name=queue_name, broker_kind=broker_kind, publish_msg_log_use_full_msg=True))
+    return jsonify({'count':publisher.get_message_count(),'success':True})
         
 @app.route('/rpc/rpc_call',methods=['POST'])
 def rpc_call():

{funboost-48.9 → funboost-49.1}/funboost/function_result_web/templates/rpc_call.html

@@ -135,7 +135,7 @@
         // 页面加载完成后立即获取所有队列
         $(document).ready(function () {
             $.ajax({
-                url: "{{ url_for('get_msg_num')}}",
+                url: "{{ url_for('get_msg_num_all_queues')}}",
                 data: {},
                 async: true,
                 success: function (result) {

{funboost-48.9 → funboost-49.1}/funboost/publishers/redis_publisher_priority.py

@@ -14,7 +14,7 @@ class RedisPriorityPublisher(FlushRedisQueueMixin,AbstractPublisher, RedisMixin,
 
     def custom_init(self):
         queue_list = [self._queue_name]
-        x_max_priority = self.publisher_params.broker_exclusive_config['x-max-priority']
+        x_max_priority = self.publisher_params.broker_exclusive_config.get('x-max-priority')
         if x_max_priority:
             for i in range(1, x_max_priority + 1):
                 queue_list.append(f'{self.queue_name}:{i}')
@@ -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-48.9 → funboost-49.1}/funboost/timing_job/timing_job_base.py

@@ -59,7 +59,7 @@ class ThreadPoolExecutorForAps(BasePoolExecutor):
         ThreadPoolExecutor constructor
     """
 
-    def __init__(self, max_workers=10, pool_kwargs=None):
+    def __init__(self, max_workers=100, pool_kwargs=None):
         pool = ThreadPoolExecutorShrinkAble(int(max_workers), )
         super().__init__(pool)
 

{funboost-48.9 → funboost-49.1}/funboost/timing_job/timing_push.py

@@ -76,9 +76,23 @@ class ApsJobAdder:
                      next_run_time=undefined, jobstore='default', executor='default',
                      replace_existing=False, **trigger_args, ):
         """
-        这里的入参都是和apscheduler的add_job的入参一样的，funboost作者没有创造新的入参。
+        1. 这里的入参都是和apscheduler的add_job的入参一样的，funboost作者没有创造新的入参。
         但是官方apscheduler的入参第一个入参是函数，
         funboost的ApsJobAdder对象.add_push_job入参去掉了函数，因为类的实例化时候会把函数传进来，不需要再麻烦用户一次了。
+        
+
+        2. add_push_job目的是 定时运行 消费函数.push方法发布消息到消费队列， 而不是 定时直接运行 消费函数自身。
+
+        相当于 aps_obj.add_job(消费函数.push, trigger, args, kwargs, id, name, .....)
+        那为什么 不直接使用 aps_obj.add_job(消费函数.push, trigger, args, kwargs, id, name, .....) 呢？因为 消费函数.push是实例方法，
+        如果redis作为 jobstore， 消费函数.push 会报错，因为 消费函数.push 是实例方法，不能被序列化。只有普通函数和静态方法才能被序列化。
+        所以开发了一个 add_push_job方法， 里面再去用 add_job， 使用 push_fun_params_to_broker 这个普通函数作为 add_job 的第一个入参，
+        这个普通函数里面再去调用 消费函数.push 方法， 相当于是曲线救国避免 aps_obj.add_job(消费函数.push 不可序列化问题。
+
+
+        3. 用户也可以自己定义一个普通函数my_push，你这个普通函数my_push 里面去调用消费函数.push方法；然后使用 aps_obj.add_job 使用你自己定义的这个my_push作为第一个入参。
+        这种方式更容易你去理解，和apscheduler 官方库的原生写法一模一样。 但是不如 add_push_job 方便，因为 需要你亲自给每个消费函数分别定义一个普通函数my_push。
+
         """
 
         # if not getattr(self.aps_obj, 'has_started_flag', False):
@@ -118,14 +132,16 @@ if __name__ == '__main__':
     ApsJobAdder(sum_two_numbers, job_store_kind='redis').add_push_job(
         trigger='date',
         run_date='2025-01-17 23:25:40',
-        args=(7, 8)
+        args=(7, 8),
+        id='date_job1'
     )
 
     # 方式2：固定间隔执行
     ApsJobAdder(sum_two_numbers, job_store_kind='memory').add_push_job(
         trigger='interval',
         seconds=5,
-        args=(4, 6)
+        args=(4, 6),
+        id='interval_job1'
     )
 
     # 方式3：使用cron表达式定时执行

{funboost-48.9 → funboost-49.1}/funboost/utils/dependency_packages_in_pythonpath/aioredis/readme.md

@@ -1,5 +1,5 @@
 ---
-noteId: "ae9b1b203c5611f09da1a79051113d13"
+noteId: "69a1b23045e411f0ab0bf59d9f569ed4"
 tags: []
 
 ---

{funboost-48.9 → funboost-49.1}/funboost/utils/dependency_packages_in_pythonpath/readme.md

@@ -1,5 +1,5 @@
 ---
-noteId: "ae9b42303c5611f09da1a79051113d13"
+noteId: "6957b0e045e411f0ab0bf59d9f569ed4"
 tags: []
 
 ---

{funboost-48.9 → funboost-49.1/funboost.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: funboost
-Version: 48.9
+Version: 49.1
 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
@@ -62,8 +62,8 @@ funboost的神奇之处在于它同时拥有"轻量级使用方式"和"重量级
 python函数加速器，框架包罗万象，一统编程思维，兼容50% python编程业务场景，适用范围广。
 python万能分布式函数调度框架，支持5种并发模式，30+种消息队列中间件
 (不仅支持几乎所有你能想到的消息队列中间件，还支持本地磁盘队列、数据库队列 (SQLAlchemy, Peewee)、
-内存队列、甚至是 HTTP 请求、WebSocket 等作为任务队列，甚至是将 Celery、Dramatiq、Huey 等其他框架整体作为其 Broker。
-funboost源码高扩展性的设计，造成“万物皆可为Broker”,并不是有30种传统意义上的经典消息队列，
+内存队列、甚至是 HTTP 请求、WebSocket 等作为任务队列，甚至是将 Celery、Dramatiq、Huey 等其他框架整体作为其
+Broker。funboost源码高扩展性的设计，造成“万物皆可为Broker”,并不是有30种传统意义上的经典消息队列，
 因为世界上总共都没有30种知名的经典消息队列)，
 30种任务控制功能。给任意python函数赋能。
 用途概念就是常规经典的 生产者 + 消息队列中间件 + 消费者 编程思想。
@@ -543,15 +543,21 @@ if __name__ == '__main__':
 
 
 队列操作：查看和操作队列，包括 清空清空 暂停消费 恢复消费 调整qps和并发
-[![pEJC6m9.png](https://s21.ax1x.com/2025/03/04/pEJC6m9.png)](https://imgse.com/i/pEJC6m9)
+<!-- [![pEJC6m9.png](https://s21.ax1x.com/2025/03/04/pEJC6m9.png)](https://imgse.com/i/pEJC6m9) -->
+[![pVSOJcq.png](https://s21.ax1x.com/2025/05/27/pVSOJcq.png)](https://imgse.com/i/pVSOJcq)
 
 队列操作，查看消费者详情：查看队列的所有消费者详情
 [![pEJCgT1.png](https://s21.ax1x.com/2025/03/04/pEJCgT1.png)](https://imgse.com/i/pEJCgT1)
 
+队列操作:查看消费曲线图，查看各种消费指标。
+[![pVpr7sP.png](https://s21.ax1x.com/2025/05/29/pVpr7sP.png)](https://imgse.com/i/pVpr7sP)
+
 rpc调用：在网页上对30种消息队列发布消息并获取消息的函数执行结；根据taskid获取结果。
 <!-- [![pETq8hj.png](https://s21.ax1x.com/2025/04/28/pETq8hj.png)](https://imgse.com/i/pETq8hj) -->
 [![pE7y8oT.png](https://s21.ax1x.com/2025/04/29/pE7y8oT.png)](https://imgse.com/i/pE7y8oT)
 
+
+
 ## 1.4  python分布式函数执行为什么重要？
 
 ```text

{funboost-48.9 → funboost-49.1}/funboost.egg-info/requires.txt

@@ -1,5 +1,5 @@
 nb_log>=13.2
-nb_libs>=1.8
+nb_libs>=1.9
 nb_time>=2.4
 pymongo>=4.6.3
 AMQPStorm==2.10.6

{funboost-48.9 → funboost-49.1}/setup.py

@@ -79,7 +79,7 @@ setup(
     ],
     install_requires=[
         'nb_log>=13.2',
-        'nb_libs>=1.8',
+        'nb_libs>=1.9',
         'nb_time>=2.4',
         "pymongo>=4.6.3",  # 3.5.1  -> 4.0.2
         'AMQPStorm==2.10.6',