funboost 50.2__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.2"
+__version__ = "50.3"
 
 from funboost.set_frame_config import show_frame_config
 

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/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/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/core/funboost_time.py

@@ -4,19 +4,20 @@ 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,12 +29,18 @@ class FunboostTime(NbTime):
         return t_str
 
 
-
-
 # 缓存时区对象，提升性能（避免重复解析）
 _tz_cache = {}
 
-def get_now_time_str_by_tz(tz_name: str=None) -> str:                   
+_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'
     
@@ -50,27 +57,64 @@ def get_now_time_str_by_tz(tz_name: str=None) -> str:
             _tz_cache[tz_name] = ZoneInfo(tz_name)
         else:
             # Python < 3.9，使用 pytz
-            try:
-                import pytz
-                _tz_cache[tz_name] = pytz.timezone(tz_name)
-            except ImportError:
-                raise RuntimeError(
-                    f"Python < 3.9 requires 'pytz' to handle timezones. "
-                    f"Install it with: pip install pytz"
-                ) from None
-            except pytz.UnknownTimeZoneError:
-                raise pytz.UnknownTimeZoneError(tz_name)
+            _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 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/helper_funs.py

@@ -3,7 +3,7 @@ import pytz
 import time
 import uuid
 import datetime
-from funboost.core.funboost_time import FunboostTime, get_now_time_str_by_tz
+from funboost.core.funboost_time import FunboostTime, get_now_time_str_by_tz, NowTimeStrCache
 
 
 def get_publish_time(paramsx: dict):
@@ -57,13 +57,13 @@ class MsgGenerater:
     def generate_publish_time() -> float:
         return round(time.time(),4)
 
-    # @staticmethod  # 性能不好
-    # def generate_publish_time_format() -> str:
-    #     return FunboostTime().get_str()
-    
+
     @staticmethod
     def generate_publish_time_format() -> str:
-        return get_now_time_str_by_tz()
+        # 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):
@@ -81,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/publishers/base_publisher.py

@@ -21,6 +21,7 @@ from threading import Lock
 import nb_log
 from funboost.constant import ConstStrForClassMethod, FunctionKind
 from funboost.core.func_params_model import PublisherParams, PriorityConsumingControlConfig
+from funboost.core.function_result_status_saver import FunctionResultStatus
 from funboost.core.helper_funs import MsgGenerater
 from funboost.core.loggers import develop_logger
 
@@ -315,6 +316,10 @@ class AbstractPublisher(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
     def concrete_realization_of_publish(self, msg: str):
         raise NotImplementedError
 
+    def sync_call(self, msg_dict: dict, is_return_rpc_data_obj=True) -> typing.Union[dict, FunctionResultStatus]:
+        """仅有部分中间件支持同步调用并阻塞等待返回结果,不依赖AsyncResult + redis作为rpc，例如 http grpc 等"""
+        raise NotImplementedError(f'broker  {self.publisher_params.broker_kind} not support sync_call method')
+
     @abc.abstractmethod
     def clear(self):
         raise NotImplementedError

funboost/publishers/http_publisher.py

@@ -1,7 +1,10 @@
 # -*- coding: utf-8 -*-
 # @Author  : ydf
 # @Time    : 2022/8/8 0008 12:12
+import threading
 
+from funboost.core.function_result_status_saver import FunctionResultStatus
+from funboost.core.serialization import Serialization
 from funboost.publishers.base_publisher import AbstractPublisher
 from urllib3 import PoolManager
 
@@ -13,7 +16,7 @@ class HTTPPublisher(AbstractPublisher, ):
 
     # noinspection PyAttributeOutsideInit
     def custom_init(self):
-        self._http = PoolManager(10)
+        self._http = PoolManager(maxsize=100)
         self._ip = self.publisher_params.broker_exclusive_config['host']
         self._port = self.publisher_params.broker_exclusive_config['port']
         self._ip_port_str = f'{self._ip}:{self._port}'
@@ -23,7 +26,22 @@ class HTTPPublisher(AbstractPublisher, ):
 
     def concrete_realization_of_publish(self, msg):
         url = self._ip_port_str + '/queue'
-        self._http.request('post', url, fields={'msg': msg})
+        self._http.request('post', url, fields={'msg': msg,'call_type':'publish'})
+
+    def sync_call(self, msg_dict: dict, is_return_rpc_data_obj=True):
+        url = self._ip_port_str + '/queue'
+        response = self._http.request('post', url, 
+                  fields={'msg': Serialization.to_json_str(msg_dict),'call_type':'sync_call'})
+        json_resp =  response.data.decode('utf-8')
+        # import requests
+        # response = requests.request('post', url, 
+        #           data={'msg': Serialization.to_json_str(msg_dict),'call_type':'sync_call'})
+        # json_resp =  response.text()
+        if is_return_rpc_data_obj:
+            return FunctionResultStatus.parse_status_and_result_to_obj(Serialization.to_dict(json_resp))
+        else:
+            return Serialization.to_dict(json_resp)
+
 
     def clear(self):
         pass  # udp没有保存消息

{funboost-50.2.dist-info → funboost-50.3.dist-info}/METADATA

@@ -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
@@ -86,6 +86,7 @@ Requires-Dist: mysql-replication ==1.0.9 ; extra == 'all'
 Requires-Dist: grpcio ==1.60.0 ; extra == 'all'
 Requires-Dist: grpcio-tools ==1.60.0 ; extra == 'all'
 Requires-Dist: protobuf ==4.25.1 ; extra == 'all'
+Requires-Dist: waitress ; extra == 'all'
 Requires-Dist: flask ; extra == 'all'
 Requires-Dist: flask-bootstrap ; extra == 'all'
 Requires-Dist: flask-wtf ; extra == 'all'
@@ -120,6 +121,7 @@ Requires-Dist: mysql-replication ==1.0.9 ; extra == 'extra_brokers'
 Requires-Dist: grpcio ==1.60.0 ; extra == 'extra_brokers'
 Requires-Dist: grpcio-tools ==1.60.0 ; extra == 'extra_brokers'
 Requires-Dist: protobuf ==4.25.1 ; extra == 'extra_brokers'
+Requires-Dist: waitress ; extra == 'extra_brokers'
 Requires-Dist: pulsar-client ==3.1.0 ; (python_version >= "3.7") and extra == 'extra_brokers'
 Provides-Extra: flask
 Requires-Dist: flask ; extra == 'flask'
@@ -168,7 +170,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 支持的并发模式:**      
@@ -206,7 +208,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框架评价:**  
@@ -235,7 +237,7 @@ funboost 框架和一般的框架不一样，因为只有一行代码需要掌
 
 只要用过 `funboost` 的用户,都评价比 `celery` 的用法简单几百倍.
 
-用户可以看文档`6.50`章节,怎么正确的用`ai`大模型掌握`funboost`的用法
+用户可以看文档`14`章节,怎么正确的用`ai`大模型掌握`funboost`的用法
 ```
 
 [**1.python万能分布式函数调度框架简funboost简介**](https://funboost.readthedocs.io/zh-cn/latest/articles/c1.html)  
@@ -739,7 +741,7 @@ python比其他语言更需要分布式函数调度框架来执行函数，有
 大部分框架，都要深入使用里面的很多个类，还需要继承组合一顿。  
 ```  
 
-用户也可以按照 文档6.50的方式,使用ai来掌握`funboost`
+用户也可以按照 文档14章节的方式,使用ai来掌握`funboost`
 
 ## 1.6 funboost支持支持celery框架整体作为funboost的broker (2023.4新增)  
 

{funboost-50.2.dist-info → funboost-50.3.dist-info}/RECORD

@@ -1,4 +1,4 @@
-funboost/__init__.py,sha256=8SYAhmWVKd3lbFTB7ns934omAwZpfPBmxG_I_IpnGAI,4093
+funboost/__init__.py,sha256=8kd6cYLc0abvVhKKfGN2yyx9auqp_CwSInI7k-cy9ZI,4093
 funboost/__init__old.py,sha256=9Kv3cPLnPkbzMRnuJFVkPsuDdx1CdcSIuITkpdncZSc,20382
 funboost/__main__.py,sha256=BetXBv7PkVeeK-UENiFq_KEEIzvObMI0rd8S1DHRdLU,1139
 funboost/constant.py,sha256=tgoui4EVwnAMMzA9qshqyRKS1oi90bYcFVNu0Ss_Jc4,14895
@@ -36,18 +36,19 @@ funboost/concurrent_pool/backup/async_pool_executor_back.py,sha256=x0pyPgxzTENOs
 funboost/concurrent_pool/backup/async_pool_executor_janus.py,sha256=OHMWJ9l3EYTpPpcrPrGGKd4K0tmQ2PN8HiX0Dta0EOo,5728
 funboost/concurrent_pool/backup/grok_async_pool.py,sha256=3DgyB2aT0iHakb-pxd51WRKGIF7EKNNcX_ogDTF2hik,5825
 funboost/consumers/__init__.py,sha256=ZXY_6Kut1VYNQiF5aWEgIWobsW1ht9YUP0TdRZRWFqI,126
-funboost/consumers/base_consumer.py,sha256=hDnuV8hPlFgtBujkirCCh2vrMUJB7MBLdP1c9upb3ss,90115
+funboost/consumers/base_consumer.py,sha256=YSYhVMUuv5V2nYZQBd-wDVdfDBTXTtqUfv25VasixKQ,90359
 funboost/consumers/celery_consumer.py,sha256=6BPZa2O36BQFVu7uWuuFCfJTTaw-36DJJPSpvEbamU8,9371
 funboost/consumers/confirm_mixin.py,sha256=5xC9AAQr_MY4tbSed8U-M6tOVmh69Qv9X0ld0JLT9Tk,6185
 funboost/consumers/dramatiq_consumer.py,sha256=ozmeAfeF0U-YNYHK4suQB0N264h5AZdfMH0O45Mh-8A,2229
 funboost/consumers/empty_consumer.py,sha256=qbkQX2Qlw2Wm8dFEJqjSEEvTA-uh184sqQbFo_5EOiI,1501
 funboost/consumers/faststream_consumer.py,sha256=4UEYGSjUwJElhy4ZGzgL7QhYVCbdVGjyZ6QuM-F0oVA,2361
-funboost/consumers/grpc_consumer.py,sha256=8y5Sl7x_S9ZI1rryePLta73TMMuEeasSRReaZnS5SIU,4058
-funboost/consumers/http_consumer.py,sha256=TlyCpjPFWdE-KIPdIhMdmAKNH8dHXIcRwrSH9NmDRQc,2499
+funboost/consumers/grpc_consumer.py,sha256=rytrYXslxNQdWrmct1pdV4E3Rxkcju3hJc6UVh3gLYY,3498
+funboost/consumers/http_consumer.py,sha256=EZiZYo14BoevFK0g1EzebTBafLSCx-CZf5c5vtWmhW4,5605
 funboost/consumers/http_consumer000.py,sha256=PiiSLSQB-hHgS1vAn8DoHD2siC3zO6_kKjVW0g6AFIc,4379
+funboost/consumers/http_consumer_aiohttp_old.py,sha256=kyqDYQT3kkDBSkQN5LhoTHHUJBYd2mPQcz3D7QMIGeU,4873
 funboost/consumers/httpsqs_consumer.py,sha256=kaqOcrKMLrSR27XqeiheRDmpF1KDVDghgbHcefTjqt8,1171
 funboost/consumers/huey_consumer.py,sha256=cW10ZPxdZQzUuJwdqQpJIRPTj2vCbZS0uXFJ7L8bpa4,1843
-funboost/consumers/kafka_consumer.py,sha256=jdQ2A0rwWJfWFLTjGknmDixi1EkjHx9Ra8VG_KD0Dyg,4637
+funboost/consumers/kafka_consumer.py,sha256=fCcClME4q_MN5Yoz_JycZhmm9fvPbh96DTG_vX7KtPU,4406
 funboost/consumers/kafka_consumer_manually_commit.py,sha256=XbExZKewuxt-z8JFo_yV9yjjw7rDbTK0F20V84Y6E_A,9929
 funboost/consumers/kombu_consumer.py,sha256=ZbzCiKQDZtbD_aK7aWxSvzARYjNuHVlyef4Feb4R7q0,7938
 funboost/consumers/local_python_queue_consumer.py,sha256=4Cel1WaNwbRpDux22USP8is5R9__A_-LlqyHjcw02Z4,1160
@@ -91,20 +92,20 @@ funboost/contrib/cdc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hS
 funboost/contrib/cdc/mysql2mysql.py,sha256=J7jLHTB27WO3iMMNU4s556b_p0x51dgnCz5c7eVWtKk,2317
 funboost/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 funboost/core/active_cousumer_info_getter.py,sha256=RF_xJMCskQImWwi7aLcIVipsp5KgDZZ4vtxBEhoPeTI,16086
-funboost/core/booster.py,sha256=E5Ler0JrA9egB0E-frN8-vwygrB9f8L_5ErUN6WoElM,21506
+funboost/core/booster.py,sha256=piykdtMO2jwnnEzuBcyPuQ5MZNZls1mVJD4SjXRkAqA,22811
 funboost/core/current_task.py,sha256=6f7IbGZaSnojVxIeyXPkk5LE2yUiRRTJBjTNqwLL2WU,7270
 funboost/core/exceptions.py,sha256=twp5eAUCds3sWh3Ar7WVNhCn3y_TFqb-Ajwbjb9scGU,1564
 funboost/core/fabric_deploy_helper.py,sha256=foieeqlNySuU9axJzNF6TavPjIUSYBx9UO3syVKUiyY,9999
 funboost/core/funboost_config_getter.py,sha256=b5nAdAmUxahskY-ohB7ptf2gKywFlDA0Fq1cWroxxbs,384
-funboost/core/funboost_time.py,sha256=hA_39jCgTXXgIQ-nLBhAgVeNkyYRvVnJ0nQ9C53juXo,3349
-funboost/core/func_params_model.py,sha256=d9hlS-FYzAELDYkdZUPRpgoRSjlTDy4x2hN2Mhz0Q7M,24842
+funboost/core/funboost_time.py,sha256=Wz7Zto7RrDoJk70-qTPncTJsIwA7HmvJBmgQLqXWzhU,5538
+funboost/core/func_params_model.py,sha256=n7fDmmdMeGcFqeqq26QmP9wU36_BqX-5ogIVSV-U9EY,26380
 funboost/core/function_result_status_config.py,sha256=PyjqAQOiwsLt28sRtH-eYRjiI3edPFO4Nde0ILFRReE,1764
 funboost/core/function_result_status_saver.py,sha256=LMLF6AROCaaYB1HIXT13L5NB6r-yezaCGeB9VSSxnQ0,9871
-funboost/core/helper_funs.py,sha256=ZFA9-GKEyhDcaXBATsbNi-yfqBYmUijtiGiUNoGjNao,2727
+funboost/core/helper_funs.py,sha256=7Pe9ax0GmS5cf3jPGPJPEjL0lrF5JB3g00DYsxX2agQ,2800
 funboost/core/kill_remote_task.py,sha256=lfclwtNhMDGLKX2UCpK_wyhnKPKkoxCZxesRA6KHOrc,8186
 funboost/core/lazy_impoter.py,sha256=yyJqwmbJziMfRTESn9magqso-_8ppl8yzHFCS5qzxkI,5104
 funboost/core/loggers.py,sha256=YY69MAP_o0Eq-CHp5UNWrKDYpoJsiHZ92E2i_fxcxRI,2358
-funboost/core/msg_result_getter.py,sha256=dhbiTDibjUxcFnmiP6gPVZn1DksyHLCdyTGmFJNQVkE,11721
+funboost/core/msg_result_getter.py,sha256=q_4jzpSGalNkIv_prRULmkreF6-yseMgUne2cna4GMo,12637
 funboost/core/muliti_process_enhance.py,sha256=tI3178inc5sqPh-jQc0XaTuUD1diIZyHuukBRk1Gp6Y,3595
 funboost/core/serialization.py,sha256=-5YdIppOSx81xaOXCryZa2nsmJ-Ro3pfV6yePcbkoEA,1240
 funboost/core/task_id_logger.py,sha256=lR19HQcX6Pp8laURCD656xNpF_JP6nLB3zUKI69EWzE,864
@@ -113,7 +114,7 @@ funboost/core/cli/discovery_boosters.py,sha256=mbEyv0bUIGcmgkfXLI_Q1IK1QvVwKyro8
 funboost/core/cli/funboost_cli_user_templ.py,sha256=XUpKLxRKtYfebPUM8wii64kB0HW8L7j9LnRpT0xCfQI,2243
 funboost/core/cli/funboost_fire.py,sha256=n2Zny_UJ7zx4kRXD_YzNBHqdHMc7n0SE7gL28tuwiPU,5387
 funboost/factories/__init__.py,sha256=s7kKKjR1HU5eMjPD6r5b-SXTVMo1zBp2JjOAtkyt5Yo,178
-funboost/factories/broker_kind__publsiher_consumer_type_map.py,sha256=XqrCglQYpVCVUiKTFaHIQBjHqObBYrGOqIvBtBqQc54,10784
+funboost/factories/broker_kind__publsiher_consumer_type_map.py,sha256=8mkp4hVYKGaHsrJPyqKykWbU-OuiEYdMdT4Eb0mS7sM,10873
 funboost/factories/consumer_factory.py,sha256=3RbdcH5fNAnumDkZhtRpDP7RsfJw50NLCgl_-YgJclE,1494
 funboost/factories/publisher_factotry.py,sha256=W5giVsQnT6pHRIC6nRANj0-XBovkuzkl0Zqcb4u5o_U,2529
 funboost/function_result_web/app.py,sha256=bEr9vdceU2cX4ZKqHDXUOQVKlobSLI_qzzzE-A3DABo,14895
@@ -174,7 +175,7 @@ funboost/function_result_web/templates/rpc_call.html,sha256=qFznWysEFTvJKUQYqnJa
 funboost/function_result_web/templates/running_consumer_by_ip.html,sha256=2Rcxbi80c1JEIRCnNe1MG55axdb0vBlkB6yL9rxw53c,10248
 funboost/function_result_web/templates/running_consumer_by_queue_name.html,sha256=r5EYlfp0fE8RFWzI0k3K571EUmirwcPX9NdnSEfAWiQ,10301
 funboost/publishers/__init__.py,sha256=xqBHlvsJQVPfbdvP84G0LHmVB7-pFBS7vDnX1Uo9pVY,131
-funboost/publishers/base_publisher.py,sha256=m3emfrFpvNYF1J-axSHH6kIY5CATzdIzfiC6P1ics_s,18806
+funboost/publishers/base_publisher.py,sha256=THtqnyemMKaS13KC1B66MeqzzFn0JNOQRFlUwWzSYkQ,19255
 funboost/publishers/celery_publisher.py,sha256=uc9N1uLW74skUCw8dsnvxORM2O3cy4SiI7tUZRmvkHA,2336
 funboost/publishers/celery_publisher000.py,sha256=2XLOyU2__vlIUTi5L15uf0BJqAIjxbc3kCLIRDSOY9w,3966
 funboost/publishers/confluent_kafka_publisher.py,sha256=B4rF6gljixOMyN6L2eL1gzqTv97uoy7TTzgKUhHljEQ,4749
@@ -182,7 +183,7 @@ funboost/publishers/dramatiq_publisher.py,sha256=IH9F-Ps1r94WDu2a7cZbJqWlBgblDbE
 funboost/publishers/empty_publisher.py,sha256=Com5m-mkjXpcWxKZZneymhLNaRJNaGAtvwjhwHmECgg,870
 funboost/publishers/faststream_publisher.py,sha256=TS_hFDZ4Q1HGyGJ_3D9m9SroUOmMo-f2hCMTyuEoEIU,2303
 funboost/publishers/grpc_publisher.py,sha256=kQ8c9VMmFXXwMz0-KyDV8VWKeAzZ20pp6KrI3rZmbRQ,1967
-funboost/publishers/http_publisher.py,sha256=1uzPXG7ExAAwOs35I-goXTi-CuZij_maRIMxc-mqvq8,1048
+funboost/publishers/http_publisher.py,sha256=CXjrcuVXC2gsJOw-KomWX4k6jzlFyTehMN89DQUNpZE,1975
 funboost/publishers/httpsqs_publisher.py,sha256=PS6h8-mn3wYFfMOsPt4tal8p0yZgYgrYYO9ZnIl9CwU,2737
 funboost/publishers/huey_publisher.py,sha256=9HBrsqTO61iPB1nI5fYOQNPuOaX4I4Wmb1BRNODAE_0,1118
 funboost/publishers/kafka_publisher.py,sha256=psjQbOmjpNHZNxyo14a09XsO0JLSSPPaBLc5mLUJTRI,2343
@@ -326,9 +327,9 @@ funboost/utils/func_timeout/dafunc.py,sha256=Yy98BzsmgWi07ja5zM4ElLwb1h8NXahxtRG
 funboost/utils/func_timeout/exceptions.py,sha256=tUEaspemq_dS460EQvUMMSxeeyjIbgfEHIdxIC6ZhaU,3974
 funboost/utils/func_timeout/py2_raise.py,sha256=9tpZLQ3-zIgU_ixazydwZmw8rFg7ybjI9alNYfSvwRk,169
 funboost/utils/func_timeout/py3_raise.py,sha256=Odvg1FtXTEC--Ru1EIfsHASamBpOm9hdXY7OnlEUObA,280
-funboost-50.2.dist-info/LICENSE,sha256=9EPP2ktG_lAPB8PjmWV-c9BiaJHc_FP6pPLcUrUwx0E,11562
-funboost-50.2.dist-info/METADATA,sha256=b6B5LYXCS9582e8Ny3VixzqZwP_J0b7Zq0IcMvjxMWQ,42120
-funboost-50.2.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-funboost-50.2.dist-info/entry_points.txt,sha256=yMSSAGRzRAAhGyNNQHw24MooKlDZsaJ499_D6fPl58A,96
-funboost-50.2.dist-info/top_level.txt,sha256=K8WuKnS6MRcEWxP1NvbmCeujJq6TEfbsB150YROlRw0,9
-funboost-50.2.dist-info/RECORD,,
+funboost-50.3.dist-info/LICENSE,sha256=9EPP2ktG_lAPB8PjmWV-c9BiaJHc_FP6pPLcUrUwx0E,11562
+funboost-50.3.dist-info/METADATA,sha256=Z2Zsq9Y2qleAbv1r1R22msVkRqIUQmmsogNzv0p_j9k,42216
+funboost-50.3.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+funboost-50.3.dist-info/entry_points.txt,sha256=yMSSAGRzRAAhGyNNQHw24MooKlDZsaJ499_D6fPl58A,96
+funboost-50.3.dist-info/top_level.txt,sha256=K8WuKnS6MRcEWxP1NvbmCeujJq6TEfbsB150YROlRw0,9
+funboost-50.3.dist-info/RECORD,,