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

funboost/core/funboost_time.py

@@ -1,22 +1,23 @@
 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()
+    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:
+    def _get_tow_digist(num: int) -> str:
+        if len(str(num)) == 1:
             return f'0{num}'
         return str(num)
 
@@ -28,9 +29,92 @@ class FunboostTime(NbTime):
         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)
+    tz = pytz.timezone(FunboostCommonConfig.TIMEZONE)
     for i in range(1000000):
         pass
         # FunboostTime()#.get_str_fast()

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

funboost/core/function_result_status_saver.py

@@ -14,7 +14,7 @@ import sys
 from pymongo import IndexModel, ReplaceOne
 
 from funboost.core.func_params_model import FunctionResultStatusPersistanceConfig
-from funboost.core.helper_funs import get_publish_time, delete_keys_and_return_new_dict
+from funboost.core.helper_funs import get_publish_time, delete_keys_and_return_new_dict, get_publish_time_format
 from funboost.core.serialization import Serialization
 from funboost.utils import time_util, decorators
 from funboost.utils.mongo_util import MongoMixin
@@ -42,9 +42,9 @@ class FunctionResultStatus():
         self.task_id = self.msg_dict.get('extra', {}).get('task_id', '')
         self.process_id = os.getpid()
         self.thread_id = threading.get_ident()
-        self.publish_time = publish_time = get_publish_time(msg_dict)
-        if publish_time:
-            self.publish_time_str = time_util.DatetimeConverter(publish_time).datetime_str
+        self.publish_time  = get_publish_time(msg_dict)
+        self.publish_time_format = get_publish_time_format(msg_dict)
+        # print(self.publish_time_format)
         function_params = delete_keys_and_return_new_dict(msg_dict, )
         self.params = function_params
         self.params_str = Serialization.to_json_str(function_params)

funboost/core/helper_funs.py

@@ -3,7 +3,7 @@ import pytz
 import time
 import uuid
 import datetime
-from funboost.core.funboost_time import FunboostTime
+from funboost.core.funboost_time import FunboostTime, get_now_time_str_by_tz, NowTimeStrCache
 
 
 def get_publish_time(paramsx: dict):
@@ -14,6 +14,14 @@ def get_publish_time(paramsx: dict):
     return paramsx.get('extra', {}).get('publish_time', None)
 
 
+def get_publish_time_format(paramsx: dict):
+    """
+    :param paramsx:
+    :return:
+    """
+    return paramsx.get('extra', {}).get('publish_time_format', None)
+
+
 def delete_keys_and_return_new_dict(dictx: dict, keys: list = None):
     dict_new = copy.deepcopy(dictx)  # 主要是去掉一级键 publish_time，浅拷贝即可。新的消息已经不是这样了。
     keys = ['publish_time', 'publish_time_format', 'extra'] if keys is None else keys
@@ -49,13 +57,18 @@ class MsgGenerater:
     def generate_publish_time() -> float:
         return round(time.time(),4)
 
+
     @staticmethod
     def generate_publish_time_format() -> str:
-        return FunboostTime().get_str()
+        # return FunboostTime().get_str()  # 性能不好
+        # return get_now_time_str_by_tz()  # 2秒100万次
+        return NowTimeStrCache.fast_get_now_time_str() # 0.4秒100万次
+
 
     @classmethod
     def generate_pulish_time_and_task_id(cls,queue_name:str,task_id=None):
-        extra_params = {'task_id': task_id or cls.generate_task_id(queue_name), 'publish_time': cls.generate_publish_time(),
+        extra_params = {'task_id': task_id or cls.generate_task_id(queue_name), 
+                        'publish_time': cls.generate_publish_time(),
                         'publish_time_format': cls.generate_publish_time_format()}
         return extra_params
 
@@ -68,8 +81,9 @@ if __name__ == '__main__':
     print(FunboostTime())
     for i in range(1000000):
         # time.time()
-        # MsgGenerater.generate_publish_time_format()
+        MsgGenerater.generate_publish_time_format()
+        # FunboostTime().get_str()
 
-        datetime.datetime.now(tz=pytz.timezone(FunboostCommonConfig.TIMEZONE)).strftime(FunboostTime.FORMATTER_DATETIME_NO_ZONE)
+        # datetime.datetime.now(tz=pytz.timezone(FunboostCommonConfig.TIMEZONE)).strftime(FunboostTime.FORMATTER_DATETIME_NO_ZONE)
 
     print(FunboostTime())

funboost/core/msg_result_getter.py

@@ -1,4 +1,5 @@
 import asyncio
+import threading
 import time
 
 import typing
@@ -278,6 +279,32 @@ class ResultFromMongo(MongoMixin):
         return (self.mongo_row or {}).get('result', NO_RESULT)
 
 
+class FutureStatusResult:
+    """
+    用于sync_call模式的结果等待和通知
+    使用threading.Event实现同步等待
+    """
+    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
+
 if __name__ == '__main__':
     print(ResultFromMongo('test_queue77h6_result:764a1ba2-14eb-49e2-9209-ac83fc5db1e8').get_status_and_result())
     print(ResultFromMongo('test_queue77h6_result:5cdb4386-44cc-452f-97f4-9e5d2882a7c1').get_result())

funboost/factories/broker_kind__publsiher_consumer_type_map.py

@@ -1,7 +1,7 @@
 import typing
 
 from funboost.publishers.empty_publisher import EmptyPublisher
-from funboost.publishers.http_publisher import HTTPPublisher
+
 from funboost.publishers.nats_publisher import NatsPublisher
 from funboost.publishers.peewee_publisher import PeeweePublisher
 from funboost.publishers.redis_publisher_lpush import RedisPublisherLpush
@@ -28,7 +28,7 @@ from funboost.publishers.httpsqs_publisher import HttpsqsPublisher
 from funboost.consumers.empty_consumer import EmptyConsumer
 from funboost.consumers.redis_consumer_priority import RedisPriorityConsumer
 from funboost.consumers.redis_pubsub_consumer import RedisPbSubConsumer
-from funboost.consumers.http_consumer import HTTPConsumer
+
 from funboost.consumers.kafka_consumer import KafkaConsumer
 from funboost.consumers.local_python_queue_consumer import LocalPythonQueueConsumer
 from funboost.consumers.mongomq_consumer import MongoMqConsumer
@@ -74,7 +74,7 @@ broker_kind__publsiher_consumer_type_map = {
     BrokerEnum.HTTPSQS: (HttpsqsPublisher, HttpsqsConsumer),
     BrokerEnum.UDP: (UDPPublisher, UDPConsumer),
     BrokerEnum.TCP: (TCPPublisher, TCPConsumer),
-    BrokerEnum.HTTP: (HTTPPublisher, HTTPConsumer),
+
     BrokerEnum.NATS: (NatsPublisher, NatsConsumer),
     BrokerEnum.TXT_FILE: (TxtFilePublisher, TxtFileConsumer),
     BrokerEnum.PEEWEE: (PeeweePublisher, PeeweeConsumer),
@@ -184,6 +184,11 @@ def regist_to_funboost(broker_kind: str):
         from funboost.consumers.mysql_cdc_consumer import MysqlCdcConsumer
         from funboost.publishers.mysql_cdc_publisher import MysqlCdcPublisher
         register_custom_broker(broker_kind, MysqlCdcPublisher, MysqlCdcConsumer)
+    
+    if broker_kind == BrokerEnum.HTTP:
+        from funboost.consumers.http_consumer import HTTPConsumer
+        from funboost.publishers.http_publisher import HTTPPublisher
+        register_custom_broker(broker_kind, HTTPPublisher, HTTPConsumer)
 
 if __name__ == '__main__':
     import sys

funboost/function_result_web/app.py

@@ -271,8 +271,27 @@ def get_time_series_data_by_queue_name(queue_name,):
     
     返回例如  [{'report_data': {'pause_flag': -1, 'msg_num_in_broker': 936748, 'history_run_count': '150180', 'history_run_fail_count': '46511', 'all_consumers_last_x_s_execute_count': 7, 'all_consumers_last_x_s_execute_count_fail': 0, 'all_consumers_last_x_s_avarage_function_spend_time': 3.441, 'all_consumers_avarage_function_spend_time_from_start': 4.598, 'all_consumers_total_consume_count_from_start': 1296, 'all_consumers_total_consume_count_from_start_fail': 314, 'report_ts': 1749617360.597841}, 'report_ts': 1749617360.597841}, {'report_data': {'pause_flag': -1, 'msg_num_in_broker': 936748, 'history_run_count': '150184', 'history_run_fail_count': '46514', 'all_consumers_last_x_s_execute_count': 7, 'all_consumers_last_x_s_execute_count_fail': 0, 'all_consumers_last_x_s_avarage_function_spend_time': 3.441, 'all_consumers_avarage_function_spend_time_from_start': 4.599, 'all_consumers_total_consume_count_from_start': 1299, 'all_consumers_total_consume_count_from_start_fail': 316, 'report_ts': 1749617370.628166}, 'report_ts': 1749617370.628166}] 
     """
+    # 获取前端传递的参数
+    start_ts = request.args.get('start_ts')
+    end_ts = request.args.get('end_ts')
+    curve_samples_count = request.args.get('curve_samples_count')
+    
+    # 如果前端指定了采样点数，使用前端的值
+    if curve_samples_count:
+        try:
+            curve_samples_count = int(curve_samples_count)
+            # 验证值是否在允许的范围内
+            allowed_values = [60, 120, 180, 360, 720, 1440,8640]
+            if curve_samples_count not in allowed_values:
+                curve_samples_count = 360  # 默认值
+        except (ValueError, TypeError):
+            curve_samples_count = 360  # 默认值
+    else:
+        # 如果前端没有指定，使用默认值
+        curve_samples_count = 360
+        
     return jsonify(QueueConusmerParamsGetter().get_time_series_data_by_queue_name(
-        queue_name,request.args.get('start_ts'),request.args.get('end_ts')))
+        queue_name, start_ts, end_ts, curve_samples_count))
         
 @app.route('/rpc/rpc_call',methods=['POST'])
 def rpc_call():