funboost 50.1__py3-none-any.whl → 50.3__py3-none-any.whl

funboost/__init__.py

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

funboost/consumers/base_consumer.py

@@ -168,8 +168,7 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         # if  self.consumer_params.concurrent_mode == ConcurrentModeEnum.ASYNC and self.consumer_params.specify_async_loop is None:
         #     self.consumer_params.specify_async_loop= get_or_create_event_loop()
         self._lock_for_count_execute_task_times_every_unit_time = Lock()
-        if self.consumer_params.concurrent_mode == ConcurrentModeEnum.ASYNC:
-            self._async_lock_for_count_execute_task_times_every_unit_time = asyncio.Lock()
+        
         # self._unit_time_for_count = 10  # 每隔多少秒计数，显示单位时间内执行多少次，暂时固定为10秒。
         # self._execute_task_times_every_unit_time = 0  # 每单位时间执行了多少次任务。
         # self._execute_task_times_every_unit_time_fail =0  # 每单位时间执行了多少次任务失败。
@@ -491,7 +490,6 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         return msg
 
     def _submit_task(self, kw):
-
         kw['body'] = self._convert_msg_before_run(kw['body'])
         self._print_message_get_from_broker(kw['body'])
         if self._judge_is_daylight():
@@ -499,6 +497,7 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
             time.sleep(self.time_interval_for_check_do_not_run_time)
             return
         function_only_params = delete_keys_and_return_new_dict(kw['body'], )
+        kw['function_only_params'] = function_only_params
         if self._get_priority_conf(kw, 'do_task_filtering') and self._redis_filter.check_value_exists(
                 function_only_params,self._get_priority_conf(kw, 'filter_str')):  # 对函数的参数进行检查，过滤已经执行过并且成功的任务。
             self.logger.warning(f'redis的 [{self._redis_filter_key_name}] 键 中 过滤任务 {kw["body"]}')
@@ -640,6 +639,9 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
     def _frame_custom_record_process_info_func(self,current_function_result_status: FunctionResultStatus,kw:dict):
         pass
 
+    async def _aio_frame_custom_record_process_info_func(self,current_function_result_status: FunctionResultStatus,kw:dict):
+        pass
+
     def user_custom_record_process_info_func(self, current_function_result_status: FunctionResultStatus,):  # 这个可以继承
         pass
 
@@ -688,7 +690,7 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
             max_retry_times = self._get_priority_conf(kw, 'max_retry_times')
             current_function_result_status = FunctionResultStatus(self.queue_name, self.consuming_function.__name__, kw['body'], )
             current_retry_times = 0
-            function_only_params = delete_keys_and_return_new_dict(kw['body'])
+            function_only_params = kw['function_only_params']
             for current_retry_times in range(max_retry_times + 1):
                 current_function_result_status.run_times = current_retry_times + 1
                 current_function_result_status.run_status = RunStatus.running
@@ -747,10 +749,10 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
     # noinspection PyProtectedMember
     def _run_consuming_function_with_confirm_and_retry(self, kw: dict, current_retry_times,
                                                        function_result_status: FunctionResultStatus, ):
-        function_only_params = delete_keys_and_return_new_dict(kw['body']) if self._do_not_delete_extra_from_msg is False else kw['body']
+        function_only_params = kw['function_only_params'] if self._do_not_delete_extra_from_msg is False else kw['body']
         task_id = kw['body']['extra']['task_id']
         t_start = time.time()
-        # function_result_status.run_times = current_retry_times + 1
+      
         fct = funboost_current_task()
         fct_context = FctContext(function_params=function_only_params,
                                  full_msg=kw['body'],
@@ -837,17 +839,47 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
 
             function_result_status.result = FunctionResultStatus.FUNC_RUN_ERROR
         return function_result_status
-
+    
+    def _gen_asyncio_objects(self):
+        if getattr(self, '_async_lock_for_count_execute_task_times_every_unit_time', None) is None:
+            self._async_lock_for_count_execute_task_times_every_unit_time = asyncio.Lock()
+        
     # noinspection PyProtectedMember
     async def _async_run(self, kw: dict, ):
-        # """虽然和上面有点大面积重复相似，这个是为了asyncio模式的，asyncio模式真的和普通同步模式的代码思维和形式区别太大，
-        # 框架实现兼容async的消费函数很麻烦复杂，连并发池都要单独写"""
+        """
+        虽然 async def _async_run 和上面的 def _run 有点大面积结构重复相似，这个是为了asyncio模式的，
+        asyncio模式真的和普通同步模式的代码思维和形式区别太大，
+        框架实现兼容async的消费函数很麻烦复杂，连并发池都要单独写
+
+        _run 和 _async_run 无法合并成一个方法：
+        因为在一个函数体内部，您无法根据条件来决定是否使用 await。
+
+        Python 语法不允许这样做：
+        # 伪代码，这是无效的
+        def _unified_run(self, kw, is_async):
+            # ...
+            if is_async:
+                await asyncio.sleep(1) # 'await' outside async function 经典报错
+            else:
+                time.sleep(1)
+
+        不能在同步函数里面去写 await,只要一个函数里出现了 await，这个函数就必须被声明为 async def
+
+
+
+        funboost 这个代价算小了,为了支持异步的全流程生态包括发布/消费/获取rpc结果,对asyncio的累计专门投入代码不到500行.
+        如果是celery 改造适配asyncio,起码要增加10倍以上的代码量,改5000行代码都搞不定支持真asyncio并发.
+        我说的是支持兼容真asyncio并发,而不是每个线程内部搞个临时loop,然后临时loop.run_until_complete(用户async函数) 这种伪asyncio并发,
+        真asyncio并发,是单个loop里面运行无数协程,
+        伪asyncio并发是在每个线程启动一个临时的loop,每个loop仅仅运行一个协程,然后等待这个协程结束,这完全违背了 asyncio 的核心初心理念,这种比多线程性能本身还差.
+        """
         try:
+            self._gen_asyncio_objects()
             t_start_run_fun = time.time()
             max_retry_times = self._get_priority_conf(kw, 'max_retry_times')
             current_function_result_status = FunctionResultStatus(self.queue_name, self.consuming_function.__name__, kw['body'], )
             current_retry_times = 0
-            function_only_params = delete_keys_and_return_new_dict(kw['body'])
+            function_only_params = kw['function_only_params']
             for current_retry_times in range(max_retry_times + 1):
                 current_function_result_status.run_times = current_retry_times + 1
                 current_function_result_status.run_status = RunStatus.running
@@ -888,11 +920,11 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
 
                 if (current_function_result_status.success is False and current_retry_times == max_retry_times) or current_function_result_status.success is True:
                     await simple_run_in_executor(push_result)
-
             async with self._async_lock_for_count_execute_task_times_every_unit_time:
                 self.metric_calculation.cal(t_start_run_fun, current_function_result_status)
 
             self._frame_custom_record_process_info_func(current_function_result_status,kw)
+            await self._aio_frame_custom_record_process_info_func(current_function_result_status,kw)
             self.user_custom_record_process_info_func(current_function_result_status,)  # 两种方式都可以自定义,记录结果.建议使用文档4.21.b的方式继承来重写
             await self.aio_user_custom_record_process_info_func(current_function_result_status,)
             if self.consumer_params.user_custom_record_process_info_func:
@@ -911,8 +943,8 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
                                                                    function_result_status: FunctionResultStatus, ):
         """虽然和上面有点大面积重复相似，这个是为了asyncio模式的，asyncio模式真的和普通同步模式的代码思维和形式区别太大，
         框架实现兼容async的消费函数很麻烦复杂，连并发池都要单独写"""
-        function_only_params = delete_keys_and_return_new_dict(kw['body']) if self._do_not_delete_extra_from_msg is False else kw['body']
-        function_result_status.run_times = current_retry_times + 1
+        function_only_params = kw['function_only_params'] if self._do_not_delete_extra_from_msg is False else kw['body']
+      
         # noinspection PyBroadException
         t_start = time.time()
         fct = funboost_current_task()

funboost/consumers/faststream_consumer.py

@@ -9,6 +9,7 @@ from faststream import FastStream,Context
 from faststream.annotations import Logger
 
 from funboost.concurrent_pool.async_helper import simple_run_in_executor
+from funboost.core.serialization import Serialization
 from funboost.core.helper_funs import delete_keys_and_return_new_dict
 
 

funboost/consumers/grpc_consumer.py

@@ -10,29 +10,12 @@ import time
 from funboost import FunctionResultStatus
 from funboost.assist.grpc_helper import funboost_grpc_pb2_grpc, funboost_grpc_pb2
 from funboost.consumers.base_consumer import AbstractConsumer
+from funboost.core.msg_result_getter import FutureStatusResult
 from funboost.core.serialization import Serialization
 from funboost.core.exceptions import FunboostWaitRpcResultTimeout
 from funboost.concurrent_pool.flexible_thread_pool import FlexibleThreadPool
 
 
-class FutureStatusResult:
-    def __init__(self,call_type:str):
-        self.execute_finish_event = threading.Event()
-        self.staus_result_obj: FunctionResultStatus = None
-        self.call_type  = call_type  # sync_call   or  publish
-
-    def set_finish(self):
-        self.execute_finish_event.set()
-
-    def wait_finish(self,rpc_timeout):
-        return self.execute_finish_event.wait(rpc_timeout)
-
-    def set_staus_result_obj(self, staus_result_obj:FunctionResultStatus):
-        self.staus_result_obj = staus_result_obj
-
-    def get_staus_result_obj(self):
-        return self.staus_result_obj
-
 
 
 

funboost/consumers/http_consumer.py

@@ -1,19 +1,23 @@
 # -*- coding: utf-8 -*-
 # @Author  : ydf
 # @Time    : 2022/8/8 0008 13:32
-import asyncio
-import json
+import logging
+import threading
 
-# from aiohttp import web
-# from aiohttp.web_request import Request
+
+from flask import Flask, request
 
 from funboost.consumers.base_consumer import AbstractConsumer
-from funboost.core.lazy_impoter import AioHttpImporter
+from funboost.core.function_result_status_saver import FunctionResultStatus
+from funboost.core.msg_result_getter import FutureStatusResult
+from funboost.core.serialization import Serialization
+
+
 
 
 class HTTPConsumer(AbstractConsumer, ):
     """
-    http 实现消息队列，不支持持久化，但不需要安装软件。
+    flask 作为消息队列实现 consumer
     """
     BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'host': '127.0.0.1', 'port': None}
 
@@ -30,42 +34,105 @@ class HTTPConsumer(AbstractConsumer, ):
         if self._port is None:
             raise ValueError('please specify port')
 
-    # noinspection DuplicatedCode
     def _shedual_task(self):
-        # flask_app = Flask(__name__)
-        #
-        # @flask_app.route('/queue', methods=['post'])
-        # def recv_msg():
-        #     msg = request.form['msg']
-        #     kw = {'body': json.loads(msg)}
-        #     self._submit_task(kw)
-        #     return 'finish'
-        #
-        # flask_app.run('0.0.0.0', port=self._port,debug=False)
+        """
+        使用Flask实现HTTP服务器
+        相比aiohttp，Flask是同步框架，避免了异步阻塞问题
+        """
+     
 
-        routes = AioHttpImporter().web.RouteTableDef()
+        # 创建Flask应用
+        flask_app = Flask(__name__)
+        # 关闭Flask的日志，避免干扰funboost的日志
+        flask_app.logger.disabled = True
+        logging.getLogger('werkzeug').disabled = True
+        
+        @flask_app.route('/', methods=['GET'])
+        def hello():
+            """健康检查接口"""
+            return "Hello, from funboost (Flask version)"
+        
+        @flask_app.route('/queue', methods=['POST'])
+        def recv_msg():
+            """
+            接收消息的核心接口
+            支持两种调用类型：
+            1. publish: 异步发布，立即返回
+            2. sync_call: 同步调用，等待结果返回
+            """
+            try:
+                # 获取请求数据
+                msg = request.form.get('msg')
+                call_type = request.form.get('call_type', 'publish')
+                
+                if not msg:
+                    return {"error": "msg parameter is required"}, 400
+                
+                # 构造消息数据
+                kw = {
+                    'body': msg,
+                    'call_type': call_type,
+                }
+                
+                if call_type == 'sync_call':
+                    # 同步调用：需要等待执行结果
+                    future_status_result = FutureStatusResult(call_type=call_type)
+                    kw['future_status_result'] = future_status_result
+                    
+                    # 提交任务到线程池执行
+                    self._submit_task(kw)
+                    
+                    # 等待任务完成（带超时）
+                    if future_status_result.wait_finish(self.consumer_params.rpc_timeout):
+                        # 返回执行结果
+                        result = future_status_result.get_staus_result_obj()
+                        return Serialization.to_json_str(
+                            result.get_status_dict(without_datetime_obj=True)
+                        )
+                    else:
+                        # 超时处理
+                        self.logger.error(f'sync_call wait timeout after {self.consumer_params.rpc_timeout}s')
+                        return {"error": "execution timeout"}, 408
+                        
+                else:
+                    # 异步发布：直接提交任务，立即返回
+                    self._submit_task(kw)
+                    return "finish"
+                    
+            except Exception as e:
+                self.logger.error(f'处理HTTP请求时出错: {e}', exc_info=True)
+                return {"error": str(e)}, 500
+        
+        # 启动Flask服务器
+        # 注意：Flask默认是单线程的，但funboost使用线程池处理任务，所以这里threaded=True
+        self.logger.info(f'启动Flask HTTP服务器，监听 {self._ip}:{self._port}')
 
-        # noinspection PyUnusedLocal
-        @routes.get('/')
-        async def hello(request):
-            return AioHttpImporter().web.Response(text="Hello, from funboost")
+        # flask_app.run(
+        #     host='0.0.0.0',  # 监听所有接口
+        #     port=self._port,
+        #     debug=False,     # 生产环境关闭debug
+        #     threaded=True,   # 开启多线程支持
+        #     use_reloader=False,  # 关闭自动重载
+        # )
 
-        @routes.post('/queue')
-        async def recv_msg(request: AioHttpImporter().Request):
-            data = await request.post()
-            msg = data['msg']
-            kw = {'body': msg}
-            self._submit_task(kw)
-            return AioHttpImporter().web.Response(text="finish")
+        import waitress
+        waitress.serve(flask_app, host='0.0.0.0', port=self._port,threads=self.consumer_params.concurrent_num)
 
-        app = AioHttpImporter().web.Application()
-        app.add_routes(routes)
-        loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(loop)
-        AioHttpImporter().web.run_app(app, host='0.0.0.0', port=self._port, )
+    def _frame_custom_record_process_info_func(self, current_function_result_status: FunctionResultStatus, kw: dict):
+        """
+        任务执行完成后的回调函数
+        对于sync_call模式，需要通知等待的HTTP请求
+        """
+        if kw['call_type'] == "sync_call":
+            future_status_result: FutureStatusResult = kw['future_status_result']
+            future_status_result.set_staus_result_obj(current_function_result_status)
+            future_status_result.set_finish()
+            # self.logger.info('sync_call任务执行完成，通知HTTP请求返回结果')
 
     def _confirm_consume(self, kw):
-        pass  # 没有确认消费的功能。
+        """HTTP模式没有确认消费的功能"""
+        pass
 
     def _requeue(self, kw):
+        """HTTP模式没有重新入队的功能"""
         pass

funboost/consumers/http_consumer_aiohttp_old.py

@@ -0,0 +1,113 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2022/8/8 0008 13:32
+import asyncio
+import json
+
+# from aiohttp import web
+# from aiohttp.web_request import Request
+
+from funboost.consumers.base_consumer import AbstractConsumer
+from funboost.core.function_result_status_saver import FunctionResultStatus
+from funboost.core.lazy_impoter import AioHttpImporter
+from funboost.core.serialization import Serialization
+
+
+class AioFutureStatusResult:
+    def __init__(self,call_type:str):
+        self.execute_finish_event = asyncio.Event()
+        self.staus_result_obj: FunctionResultStatus = None
+        self.call_type  = call_type  # sync_call   or  publish
+
+    def set_finish(self):
+        self.execute_finish_event.set()
+
+    async def wait_finish(self,rpc_timeout):
+        return await self.execute_finish_event.wait()
+
+    def set_staus_result_obj(self, staus_result_obj:FunctionResultStatus):
+        self.staus_result_obj = staus_result_obj
+
+    def get_staus_result_obj(self):
+        return self.staus_result_obj
+
+class HTTPConsumer(AbstractConsumer, ):
+    """
+    aiohttp 实现消息队列，不支持持久化，但不需要安装软件。
+    """
+    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'host': '127.0.0.1', 'port': None}
+
+    # noinspection PyAttributeOutsideInit
+    def custom_init(self):
+        # try:
+        #     self._ip, self._port = self.queue_name.split(':')
+        #     self._port = int(self._port)
+        # except BaseException as e:
+        #     self.logger.critical(f'http作为消息队列时候,队列名字必须设置为 例如 192.168.1.101:8200  这种,  ip:port')
+        #     raise e
+        self._ip = self.consumer_params.broker_exclusive_config['host']
+        self._port = self.consumer_params.broker_exclusive_config['port']
+        if self._port is None:
+            raise ValueError('please specify port')
+
+    # noinspection DuplicatedCode
+    def _shedual_task(self):
+        # flask_app = Flask(__name__)
+        #
+        # @flask_app.route('/queue', methods=['post'])
+        # def recv_msg():
+        #     msg = request.form['msg']
+        #     kw = {'body': json.loads(msg)}
+        #     self._submit_task(kw)
+        #     return 'finish'
+        #
+        # flask_app.run('0.0.0.0', port=self._port,debug=False)
+
+        routes = AioHttpImporter().web.RouteTableDef()
+
+        # noinspection PyUnusedLocal
+        @routes.get('/')
+        async def hello(request):
+            return AioHttpImporter().web.Response(text="Hello, from funboost")
+
+        @routes.post('/queue')
+        async def recv_msg(request: AioHttpImporter().Request):
+            data = await request.post()
+            msg = data['msg']
+            call_type = data['call_type']
+            kw = {'body': msg,'call_type': call_type,}
+            if call_type == 'sync_call':
+                aio_future_status_result = AioFutureStatusResult(call_type=call_type)
+                kw['aio_future_status_result'] = aio_future_status_result
+            self._submit_task(kw)
+            if data['call_type'] == 'sync_call':
+                await aio_future_status_result.wait_finish(self.consumer_params.rpc_timeout)
+                return AioHttpImporter().web.Response(text=Serialization.to_json_str(
+                    aio_future_status_result.get_staus_result_obj().get_status_dict(without_datetime_obj=True)))
+            return AioHttpImporter().web.Response(text="finish")
+
+        app = AioHttpImporter().web.Application()
+        app.add_routes(routes)
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        AioHttpImporter().web.run_app(app, host='0.0.0.0', port=self._port, )
+
+    def _frame_custom_record_process_info_func(self,current_function_result_status: FunctionResultStatus,kw:dict):
+        if  kw['call_type'] == "sync_call":
+            aio_future_status_result: AioFutureStatusResult = kw['aio_future_status_result']
+            aio_future_status_result.set_staus_result_obj(current_function_result_status)
+            aio_future_status_result.set_finish()
+            self.logger.info(f'aio_future_status_result.set_finish()')
+
+    # async def _aio_frame_custom_record_process_info_func(self,current_function_result_status: FunctionResultStatus,kw:dict):
+    #     self.logger.info(666666)
+    #     if kw['call_type'] == "sync_call":
+    #         aio_future_status_result: AioFutureStatusResult = kw['aio_future_status_result']
+    #         aio_future_status_result.set_staus_result_obj(current_function_result_status)
+    #         aio_future_status_result.set_finish()
+    #         self.logger.info(f'aio_future_status_result.set_finish()')
+    def _confirm_consume(self, kw):
+        pass  # 没有确认消费的功能。
+
+    def _requeue(self, kw):
+        pass

funboost/consumers/kafka_consumer.py

@@ -60,10 +60,7 @@ class KafkaConsumer(AbstractConsumer):
         # REMIND 好处是并发高。topic像翻书一样，随时可以设置偏移量重新消费。多个分组消费同一个主题，每个分组对相同主题的偏移量互不干扰 。
         for message in consumer:
             # 注意: message ,value都是原始的字节数据，需要decode
-            if self.consumer_params.is_show_message_get_from_broker:
-                self.logger.debug(
-                    f'从kafka的 [{message.topic}] 主题,分区 {message.partition} 中 取出的消息是：  {message.value.decode()}')
-            kw = {'consumer': consumer, 'message': message, 'body': message.value}
+            kw = {'consumer': consumer, 'message': message, 'body': message.value.decode('utf-8')}
             self._submit_task(kw)
 
     def _confirm_consume(self, kw):

funboost/core/active_cousumer_info_getter.py

@@ -205,12 +205,13 @@ class QueueConusmerParamsGetter(RedisMixin, FunboostFileLoggerMixin):
         def _inner():
             while True:
                 t_start = time.time()
-                # 这个函数确保只有一个地方在上报数据，避免重复上报
+                # 这个函数确保只有一个地方在上报数据，避免重复采集上报
                 report_ts = self.timestamp()
                 redis_report_uuid_ts_str = self.redis_db_frame.get(RedisKeys.FUNBOOST_LAST_GET_QUEUE_PARAMS_AND_ACTIVE_CONSUMERS_AND_REPORT__UUID_TS, )
                 if redis_report_uuid_ts_str:
                     redis_report_uuid_ts = Serialization.to_dict(redis_report_uuid_ts_str)
                     if redis_report_uuid_ts['report_uuid'] != report_uuid and redis_report_uuid_ts['report_ts'] > report_ts - time_interval - 10 :
+                        time.sleep(5) # 防止cpu空转
                         continue
                 self.redis_db_frame.set(RedisKeys.FUNBOOST_LAST_GET_QUEUE_PARAMS_AND_ACTIVE_CONSUMERS_AND_REPORT__UUID_TS,
                                         Serialization.to_json_str({'report_uuid':report_uuid, 'report_ts':report_ts}))
@@ -229,17 +230,38 @@ class QueueConusmerParamsGetter(RedisMixin, FunboostFileLoggerMixin):
                         RedisKeys.gen_funboost_queue_time_series_data_key_by_queue_name(queue),
                         0, report_ts - 86400
                     )
-                self.logger.info(f'上报时序数据耗时 {time.time() - t_start} 秒')
+                self.logger.info(f'采集上报时序数据耗时 {time.time() - t_start} 秒')
 
                 time.sleep(time_interval)
         threading.Thread(target=_inner, daemon=daemon).start()
 
-    def get_time_series_data_by_queue_name(self,queue_name,start_ts=None,end_ts=None):
+    def get_time_series_data_by_queue_name(self,queue_name,start_ts=None,end_ts=None,curve_samples_count=None):
         res = self.redis_db_frame.zrangebyscore(
             RedisKeys.gen_funboost_queue_time_series_data_key_by_queue_name(queue_name),
             max(float(start_ts or 0),self.timestamp() - 86400) ,float(end_ts or -1),withscores=True)
         # print(res)
-        return [{'report_data':Serialization.to_dict(item[0]),'report_ts':item[1]} for item in res]
+        series_data_all= [{'report_data':Serialization.to_dict(item[0]),'report_ts':item[1]} for item in res]
+        if curve_samples_count is None:
+            return series_data_all
+        
+        # 曲线采样数量
+        total_count = len(series_data_all)
+        if total_count <= curve_samples_count:
+            # 如果原始数据量小于等于需要的样本数，直接返回全部数据
+            return series_data_all
+        
+        # 计算采样步长
+        step = total_count / curve_samples_count
+        sampled_data = []
+        
+        # 按照步长进行采样
+        for i in range(curve_samples_count):
+            index = int(i * step)
+            if index < total_count:
+                sampled_data.append(series_data_all[index])
+        
+        return sampled_data
+        
 
 if __name__ == '__main__':
     # print(Serialization.to_json_str(QueueConusmerParamsGetter().get_queue_params_and_active_consumers()))

funboost/core/booster.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 import copy
 import inspect
+from multiprocessing import Process
 import os
 import sys
 import types
@@ -242,10 +243,10 @@ class BoostersManager:
     """
 
     # pid_queue_name__booster_map字典存放 {(进程id,queue_name):Booster对象}
-    pid_queue_name__booster_map = {}  # type: typing.Dict[typing.Tuple[int,str],Booster]
+    pid_queue_name__booster_map :typing.Dict[typing.Tuple[int,str],Booster]= {}  
 
     # queue_name__boost_params_consuming_function_map 字典存放  {queue_name,(@boost的入参字典,@boost装饰的消费函数)}
-    queue_name__boost_params_map = {}  # type: typing.Dict[str,BoosterParams]
+    queue_name__boost_params_map :typing.Dict[str,BoosterParams]= {}  
 
     pid_queue_name__has_start_consume_set = set()
 
@@ -392,6 +393,34 @@ class BoostersManager:
 
     m_consume = multi_process_consume_queues
 
+    @classmethod
+    def consume_group(cls, booster_group:str,block=False):
+        """
+        根据@boost装饰器的 booster_group消费分组名字,启动多个消费函数;
+        """
+        if booster_group is None:
+            raise ValueError('booster_group 不能为None')
+        need_consume_queue_names = []
+        for queue_name in cls.get_all_queues():
+            booster= cls.get_or_create_booster_by_queue_name(queue_name)
+            if booster.boost_params.booster_group == booster_group:
+                need_consume_queue_names.append(queue_name)
+        flogger.info(f'according to booster_group:{booster_group} ,start consume queues: {need_consume_queue_names}')
+        for queue_name in need_consume_queue_names:
+            cls.get_or_create_booster_by_queue_name(queue_name).consume()
+        if block:
+            ctrl_c_recv()
+
+    @classmethod
+    def multi_process_consume_group(cls, booster_group:str, process_num=1):
+        """
+        根据@boost装饰器的 booster_group消费分组名字,启动多个消费函数;
+        """
+        for _ in range(process_num):
+            Process(target=cls.consume_group,args=(booster_group,True)).start()
+    
+    m_consume_group = multi_process_consume_group
+            
     @classmethod
     def multi_process_consume_all_queues(cls, process_num=1):
         """