funboost 50.2__tar.gz → 50.3__tar.gz

{funboost-50.2/funboost.egg-info → funboost-50.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: funboost
-Version: 50.2
+Version: 50.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,7 +73,7 @@ pip install funboost --upgrade
 `funboost`是`函数增强器,属于轻型自由框架`,你可以对任意项目任意位置的新旧函数加上`@boost`装饰器,是给你函数赋能插上强大翅膀,用户不需要围绕`funboost`或某个中央app实例来组织代码结构,用户函数自身就是一等公民   
 
 2个框架最显而易见明显差别就是 `funboost` 无需 `@app.boost` 而是直接`@boost`,这个小区别,造成影响深远的框架用法和理念区别.   
-`funboost`任务控制功能更多,支持broker中间件种类更多,并发方式更多,发布性能超越celery 22倍,消费性能超越 celery 40倍,性能是高几个数量级的断崖式遥遥领先,但反而使用比celery简单得多.  
+`funboost`任务控制功能更多,支持broker中间件种类更多,并发方式更多,发布性能超越celery 22倍,消费性能超越 celery 46倍,性能是高几个数量级的断崖式遥遥领先,但反而使用比celery简单得多.  
 ```
 
 #### **funboost 支持的并发模式:**      
@@ -111,7 +111,7 @@ pip install funboost --upgrade
 通过`funboost web manager` 管理系统，支持全面 查看 监控 管理 `funboost`的任务消费。  
 
 #### **funboost的性能超过`celery`一个数量级,不是一个档次上:**    
-`funboost`发布性能是`celery`的22倍,`funboost`消费性能是`celery`的40倍! 控制变量法对比方式,见文档2.6章节
+`funboost`发布性能是`celery`的22倍,`funboost`消费性能是`celery`的46倍! 控制变量法对比方式,见文档2.6章节
 
 
 #### **funboost框架评价:**  
@@ -140,7 +140,7 @@ funboost 框架和一般的框架不一样，因为只有一行代码需要掌
 
 只要用过 `funboost` 的用户,都评价比 `celery` 的用法简单几百倍.
 
-用户可以看文档`6.50`章节,怎么正确的用`ai`大模型掌握`funboost`的用法
+用户可以看文档`14`章节,怎么正确的用`ai`大模型掌握`funboost`的用法
 ```
 
 [**1.python万能分布式函数调度框架简funboost简介**](https://funboost.readthedocs.io/zh-cn/latest/articles/c1.html)  
@@ -644,7 +644,7 @@ python比其他语言更需要分布式函数调度框架来执行函数，有
 大部分框架，都要深入使用里面的很多个类，还需要继承组合一顿。  
 ```  
 
-用户也可以按照 文档6.50的方式,使用ai来掌握`funboost`
+用户也可以按照 文档14章节的方式,使用ai来掌握`funboost`
 
 ## 1.6 funboost支持支持celery框架整体作为funboost的broker (2023.4新增)  
 

{funboost-50.2 → funboost-50.3}/README.md

@@ -38,7 +38,7 @@ pip install funboost --upgrade
 `funboost`是`函数增强器,属于轻型自由框架`,你可以对任意项目任意位置的新旧函数加上`@boost`装饰器,是给你函数赋能插上强大翅膀,用户不需要围绕`funboost`或某个中央app实例来组织代码结构,用户函数自身就是一等公民   
 
 2个框架最显而易见明显差别就是 `funboost` 无需 `@app.boost` 而是直接`@boost`,这个小区别,造成影响深远的框架用法和理念区别.   
-`funboost`任务控制功能更多,支持broker中间件种类更多,并发方式更多,发布性能超越celery 22倍,消费性能超越 celery 40倍,性能是高几个数量级的断崖式遥遥领先,但反而使用比celery简单得多.  
+`funboost`任务控制功能更多,支持broker中间件种类更多,并发方式更多,发布性能超越celery 22倍,消费性能超越 celery 46倍,性能是高几个数量级的断崖式遥遥领先,但反而使用比celery简单得多.  
 ```
 
 #### **funboost 支持的并发模式:**      
@@ -76,7 +76,7 @@ pip install funboost --upgrade
 通过`funboost web manager` 管理系统，支持全面 查看 监控 管理 `funboost`的任务消费。  
 
 #### **funboost的性能超过`celery`一个数量级,不是一个档次上:**    
-`funboost`发布性能是`celery`的22倍,`funboost`消费性能是`celery`的40倍! 控制变量法对比方式,见文档2.6章节
+`funboost`发布性能是`celery`的22倍,`funboost`消费性能是`celery`的46倍! 控制变量法对比方式,见文档2.6章节
 
 
 #### **funboost框架评价:**  
@@ -105,7 +105,7 @@ funboost 框架和一般的框架不一样，因为只有一行代码需要掌
 
 只要用过 `funboost` 的用户,都评价比 `celery` 的用法简单几百倍.
 
-用户可以看文档`6.50`章节,怎么正确的用`ai`大模型掌握`funboost`的用法
+用户可以看文档`14`章节,怎么正确的用`ai`大模型掌握`funboost`的用法
 ```
 
 [**1.python万能分布式函数调度框架简funboost简介**](https://funboost.readthedocs.io/zh-cn/latest/articles/c1.html)  
@@ -609,7 +609,7 @@ python比其他语言更需要分布式函数调度框架来执行函数，有
 大部分框架，都要深入使用里面的很多个类，还需要继承组合一顿。  
 ```  
 
-用户也可以按照 文档6.50的方式,使用ai来掌握`funboost`
+用户也可以按照 文档14章节的方式,使用ai来掌握`funboost`
 
 ## 1.6 funboost支持支持celery框架整体作为funboost的broker (2023.4新增)  
 

{funboost-50.2 → funboost-50.3}/funboost/__init__.py

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

{funboost-50.2 → funboost-50.3}/funboost/consumers/base_consumer.py

@@ -639,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
 
@@ -921,6 +924,7 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
                 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:

{funboost-50.2 → funboost-50.3}/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-50.3/funboost/consumers/http_consumer.py

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2022/8/8 0008 13:32
+import logging
+import threading
+
+
+from flask import Flask, request
+
+from funboost.consumers.base_consumer import AbstractConsumer
+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, ):
+    """
+    flask 作为消息队列实现 consumer
+    """
+    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')
+
+    def _shedual_task(self):
+        """
+        使用Flask实现HTTP服务器
+        相比aiohttp，Flask是同步框架，避免了异步阻塞问题
+        """
+     
+
+        # 创建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}')
+
+        # flask_app.run(
+        #     host='0.0.0.0',  # 监听所有接口
+        #     port=self._port,
+        #     debug=False,     # 生产环境关闭debug
+        #     threaded=True,   # 开启多线程支持
+        #     use_reloader=False,  # 关闭自动重载
+        # )
+
+        import waitress
+        waitress.serve(flask_app, host='0.0.0.0', port=self._port,threads=self.consumer_params.concurrent_num)
+
+    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):
+        """HTTP模式没有确认消费的功能"""
+        pass
+
+    def _requeue(self, kw):
+        """HTTP模式没有重新入队的功能"""
+        pass

funboost-50.3/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-50.2 → funboost-50.3}/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-50.2 → funboost-50.3}/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):
         """

funboost-50.3/funboost/core/funboost_time.py

@@ -0,0 +1,130 @@
+import pytz
+import time
+import sys
+import datetime
+
+import typing
+import threading
+from nb_time import NbTime
+from funboost.funboost_config_deafult import FunboostCommonConfig
+
+
+class FunboostTime(NbTime):
+    default_formatter = NbTime.FORMATTER_DATETIME_NO_ZONE
+
+    def get_time_zone_str(self, time_zone: typing.Union[str, datetime.tzinfo, None] = None):
+        return time_zone or self.default_time_zone or FunboostCommonConfig.TIMEZONE or self.get_localzone_name()
+
+    @staticmethod
+    def _get_tow_digist(num: int) -> str:
+        if len(str(num)) == 1:
+            return f'0{num}'
+        return str(num)
+
+    def get_str(self, formatter=None):
+        return self.datetime_obj.strftime(formatter or self.datetime_formatter)
+
+    def get_str_fast(self):
+        t_str = f'{self.datetime_obj.year}-{self._get_tow_digist(self.datetime_obj.month)}-{self._get_tow_digist(self.datetime_obj.day)} {self._get_tow_digist(self.datetime_obj.hour)}:{self._get_tow_digist(self.datetime_obj.minute)}:{self._get_tow_digist(self.datetime_obj.second)}'
+        return t_str
+
+
+# 缓存时区对象，提升性能（避免重复解析）
+_tz_cache = {}
+
+_DIGIT_MAP = {i: f'{i:02d}' for i in range(100)}
+
+
+def _gen_2_dig_number(n):
+    return _DIGIT_MAP[n]
+
+
+def get_now_time_str_by_tz(tz_name: str = None) -> str:
+    # 生成100万次当前时间字符串%Y-%m-%d %H:%M:%S仅需1.9秒.              
+    """
+    根据时区名（如 'Asia/Shanghai'）返回当前时间字符串，格式：'%Y-%m-%d %H:%M:%S'
+    
+    兼容 Python 3.6+，优先使用 zoneinfo（3.9+），否则尝试 pytz
+    
+    :param tz_name: IANA 时区名称，如 'Asia/Shanghai', 'America/New_York'
+    :return: 格式化时间字符串
+    """
+    # 检查缓存
+    tz_name = tz_name or FunboostCommonConfig.TIMEZONE
+    if tz_name not in _tz_cache:
+        if sys.version_info >= (3, 9):
+            from zoneinfo import ZoneInfo
+            _tz_cache[tz_name] = ZoneInfo(tz_name)
+        else:
+            # Python < 3.9，使用 pytz
+            _tz_cache[tz_name] = pytz.timezone(tz_name)
+
+
+    tz = _tz_cache[tz_name]
+
+    # 获取当前时间并格式化（注意：datetime.now(tz) 是最高效的方式）
+    now = datetime.datetime.now(tz)
+    # return f'{now.year:04d}-{now.month:02d}-{now.day:02d} {now.hour:02d}:{now.minute:02d}:{now.second:02d}'
+    # return now.strftime("%Y-%m-%d %H:%M:%S")
+    return f'{now.year}-{_gen_2_dig_number(now.month)}-{_gen_2_dig_number(now.day)} {_gen_2_dig_number(now.hour)}:{_gen_2_dig_number(now.minute)}:{_gen_2_dig_number(now.second)}'
+
+
+class NowTimeStrCache:
+    # 生成100万次当前时间字符串%Y-%m-%d %H:%M:%S仅需0.4秒.
+    # 全局变量，用于存储缓存的时间字符串和对应的整秒时间戳
+    _cached_time_str: typing.Optional[str] = None
+    _cached_time_second: int = 0
+
+    # 为了线程安全，使用锁。在极高并发下，锁的开销远小于每毫秒都进行时间格式化。
+    _time_cache_lock = threading.Lock()
+
+    @classmethod
+    def fast_get_now_time_str(cls,timezone_str:str=None) -> str:
+        """
+        获取当前时间字符串，格式为 '%Y-%m-%d %H:%M:%S'。
+        通过缓存机制，同一秒内的多次调用直接返回缓存结果，极大提升性能。
+        适用于对时间精度要求不高（秒级即可）的高并发场景。
+        :return: 格式化后的时间字符串，例如 '2024-06-12 15:30:45'
+        """
+        timezone_str = timezone_str or FunboostCommonConfig.TIMEZONE
+
+        # 获取当前的整秒时间戳（去掉小数部分）
+        current_second = int(time.time())
+
+        # 如果缓存的时间戳与当前秒数一致，直接返回缓存的字符串。
+        if current_second == cls._cached_time_second:
+            return cls._cached_time_str
+
+        # 如果不一致，说明进入新的一秒，需要重新计算并更新缓存。
+        # 使用锁确保在多线程环境下，只有一个线程会执行更新操作。
+
+        with cls._time_cache_lock:
+            # 双重检查锁定 (Double-Checked Locking)，防止在等待锁的过程中，其他线程已经更新了缓存。
+            if current_second == cls._cached_time_second:
+                return cls._cached_time_str
+
+            # 重新计算时间字符串。这里直接使用 time.strftime，因为它在秒级更新的场景下性能足够。
+            # 我们不需要像 Funboost 那样为每一毫秒的调用都去做查表优化。
+            now = datetime.datetime.now(tz=pytz.timezone(timezone_str))
+            cls._cached_time_str = now.strftime('%Y-%m-%d %H:%M:%S', )
+            cls._cached_time_second = current_second
+
+        return cls._cached_time_str
+
+
+if __name__ == '__main__':
+    print(FunboostTime().get_str())
+    tz = pytz.timezone(FunboostCommonConfig.TIMEZONE)
+    for i in range(1000000):
+        pass
+        # FunboostTime()#.get_str_fast()
+
+        # datetime.datetime.now().strftime(NbTime.FORMATTER_DATETIME_NO_ZONE)
+        tz = pytz.timezone(FunboostCommonConfig.TIMEZONE)
+        datetime.datetime.now(tz=tz)
+        # datetime.datetime.now(tz=pytz.timezone(FunboostCommonConfig.TIMEZONE))#.strftime(NbTime.FORMATTER_DATETIME_NO_ZONE)
+        # datetime.datetime.now(tz=pytz.timezone(FunboostCommonConfig.TIMEZONE)).timestamp()
+
+        # time.strftime(NbTime.FORMATTER_DATETIME_NO_ZONE)
+        # time.time()
+    print(NbTime())

{funboost-50.2 → funboost-50.3}/funboost/core/func_params_model.py

@@ -201,12 +201,17 @@ class BoosterParams(BaseJsonAbleModel):
     schedule_tasks_on_main_thread: bool = False  # 直接在主线程调度任务，意味着不能直接在当前主线程同时开启两个消费者。
 
     is_auto_start_consuming_message: bool = False  # 是否在定义后就自动启动消费，无需用户手动写 .consume() 来启动消息消费。
+    
+    # booster_group :消费分组名字， BoostersManager.consume_group 时候根据 booster_group 启动多个消费函数,减少需要写 f1.consume() f2.consume() ...这种。
+    # 不像BoostersManager.consume_all() 会启动所有不相关消费函数,也不像  f1.consume() f2.consume() 这样需要逐个启动消费函数。
+    # 可以根据业务逻辑创建不同的分组，实现灵活的消费启动策略。
+    # 用法见文档 4.2d.3 章节.   使用 BoostersManager ,通过 consume_group 启动一组消费函数
+    booster_group:typing.Union[str, None] = None
 
     consuming_function: typing.Optional[typing.Callable] = None  # 消费函数,在@boost时候不用指定,因为装饰器知道下面的函数.
     consuming_function_raw: typing.Optional[typing.Callable] = None  # 不需要传递，自动生成
     consuming_function_name: str = '' # 不需要传递，自动生成
 
-    
 
     broker_exclusive_config: dict = {}  # 加上一个不同种类中间件非通用的配置,不同中间件自身独有的配置，不是所有中间件都兼容的配置，因为框架支持30种消息队列，消息队列不仅仅是一般的先进先出queue这么简单的概念，
     # 例如kafka支持消费者组，rabbitmq也支持各种独特概念例如各种ack机制 复杂路由机制，有的中间件原生能支持消息优先级有的中间件不支持,每一种消息队列都有独特的配置参数意义，可以通过这里传递。每种中间件能传递的键值对可以看consumer类的 BROKER_EXCLUSIVE_CONFIG_DEFAULT
@@ -228,9 +233,20 @@ class BoosterParams(BaseJsonAbleModel):
         COMMON_FUNCTION = 'COMMON_FUNCTION'
     """
 
+    """
+    user_options:
+    用户额外自定义的配置,高级用户或者奇葩需求可以用得到,用户可以自由发挥,存放任何设置.
+    user_options 提供了一个统一的、用户自定义的命名空间，让用户可以为自己的“奇葩需求”或“高级定制”传递配置，而无需等待框架开发者添加官方支持。
+    funboost 是自由框架不是奴役框架,不仅消费函数逻辑自由,目录层级结构自由,自定义奇葩扩展也要追求自由,用户不用改funboost BoosterParams 源码来加装饰器参数
+    
+    使用场景见文档 4b.6 章节.
+    """
+    user_options: dict = {} # 用户自定义的配置,高级用户或者奇葩需求可以用得到,用户可以自由发挥,存放任何设置.
+    
+    
     auto_generate_info: dict = {}  # 自动生成的信息,不需要用户主动传参.
-
-
+    
+    
 
     @root_validator(skip_on_failure=True, )
     def check_values(cls, values: dict):
@@ -358,6 +374,8 @@ class PublisherParams(BaseJsonAbleModel):
     publish_msg_log_use_full_msg: bool = False # 发布到消息队列的消息内容的日志，是否显示消息的完整体，还是只显示函数入参。
     consuming_function_kind: typing.Optional[str] = None  # 自动生成的信息,不需要用户主动传参.
     rpc_timeout: int = 1800 # rpc模式下，等待rpc结果返回的超时时间
+    user_options: dict = {}  # 用户自定义的配置,高级用户或者奇葩需求可以用得到,用户可以自由发挥,存放任何设置.
+
 
 if __name__ == '__main__':
     from funboost.concurrent_pool import FlexibleThreadPool