funboost 49.6__py3-none-any.whl → 49.8__py3-none-any.whl

funboost/__init__.py

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

funboost/concurrent_pool/async_pool_executor.py

@@ -6,6 +6,7 @@ import threading
 import time
 import traceback
 from threading import Thread
+import traceback
 
 from funboost.concurrent_pool.base_pool_type import FunboostBaseConcurrentPool
 from funboost.core.loggers import FunboostFileLoggerMixin
@@ -53,14 +54,17 @@ class AsyncPoolExecutor(FunboostFileLoggerMixin,FunboostBaseConcurrentPool):
     使api和线程池一样，最好的性能做法是submit也弄成 async def，生产和消费在同一个线程同一个loop一起运行，但会对调用链路的兼容性产生破坏，从而调用方式不兼容线程池。
     """
 
-    def __init__(self, size, loop=None):
+    def __init__(self, size, specify_async_loop=None,
+                 is_auto_start_specify_async_loop_in_child_thread=True):
         """
 
         :param size: 同时并发运行的协程任务数量。
-        :param loop:
+        :param specify_loop: 可以指定loop,异步三方包的连接池发请求不能使用不同的loop去使用连接池.
         """
         self._size = size
-        self.loop = loop or asyncio.new_event_loop()
+        self._specify_async_loop = specify_async_loop
+        self._is_auto_start_specify_async_loop_in_child_thread = is_auto_start_specify_async_loop_in_child_thread
+        self.loop = specify_async_loop or asyncio.new_event_loop()
         asyncio.set_event_loop(self.loop)
         self._diff_init()
         # self._lock = threading.Lock()
@@ -120,11 +124,16 @@ class AsyncPoolExecutor(FunboostFileLoggerMixin,FunboostBaseConcurrentPool):
         # self.loop.run_until_complete(asyncio.wait([self._consume() for _ in range(self._size)], loop=self.loop))
         # self._can_be_closed_flag = True
         [self.loop.create_task(self._consume()) for _ in range(self._size)]
-        try:
+        if self._specify_async_loop is None:
             self.loop.run_forever()
-        except Exception as e:
-            self.logger.warning(f'{e}')   # 如果多个线程使用一个loop，不能重复启动loop，否则会报错。
-
+        else:
+            if self._is_auto_start_specify_async_loop_in_child_thread:
+                try:
+                    self.loop.run_forever() #如果是指定的loop不能多次启动一个loop.
+                except Exception as e:
+                    self.logger.warning(f'{e} {traceback.format_exc()}')   # 如果多个线程使用一个loop，不能重复启动loop，否则会报错。
+            else:
+                pass # 用户需要自己在自己的业务代码中去手动启动loop.run_forever() 
 
 
     # def shutdown(self):
@@ -139,14 +148,6 @@ class AsyncPoolExecutor(FunboostFileLoggerMixin,FunboostBaseConcurrentPool):
 
 
 
-
-
-
-
-
-
-
-
 if __name__ == '__main__':
     def test_async_pool_executor():
         from funboost.concurrent_pool import CustomThreadPoolExecutor as ThreadPoolExecutor

funboost/constant.py

@@ -3,6 +3,25 @@
 
 
 class BrokerEnum:
+    """
+    在funboost中万物皆可为消息队列broker,funboost内置了所有 知名的正经经典消息队列作为broker,
+    也支持了基于 内存 各种数据库 文件系统 tcp/udp/http这些socket 模拟作为broker.
+    funboost也内置支持了各种python三方包和消费框架作为broker,例如 sqlachemy kombu celery rq dramtiq huey nameko 等等
+
+    用户也可以按照文档4.21章节,轻松扩展任何物质概念作为funboost的broker.
+    """
+    
+    # funboost框架能轻松兼容消息队列各种工作模式, 拉模式/推模式/轮询模式，单条获取 批量获取
+    """
+    funboost 的 consumer的 _shedual_task 非常灵活，用户实现把从消息队列取出的消息通过_submit_task方法
+    丢到并发池，他不是强制用户重写实现怎么取一条消息，例如强制你实现一个 _get_one_message的法，
+    那就不灵活和限制扩展任意东西作为broker了，而是用户完全自己来写灵活代码。
+    所以无论获取消息是 拉模式 还是推模式 还是轮询模式，是单条获取 还是多条批量获取，
+    不管你的新中间件和rabbitmq api用法差别有多么巨大，都能轻松扩展任意东西作为funboost的中间件。 
+    所以你能看到funboost源码中能轻松实现任物质概念作为funboost的broker。
+    """
+
+
     EMPTY = 'EMPTY'  # 空的实现，需要搭配 boost入参的 consumer_override_cls 和 publisher_override_cls使用，或者被继承。
 
     RABBITMQ_AMQPSTORM = 'RABBITMQ_AMQPSTORM'  # 使用 amqpstorm 包操作rabbitmq  作为 分布式消息队列，支持消费确认.强烈推荐这个作为funboost中间件。

funboost/consumers/base_consumer.py

@@ -37,7 +37,7 @@ from funboost.core.current_task import funboost_current_task, FctContext
 from funboost.core.loggers import develop_logger
 
 from funboost.core.func_params_model import BoosterParams, PublisherParams, BaseJsonAbleModel
-from funboost.core.serialization import Serialization
+from funboost.core.serialization import PickleHelper, Serialization
 from funboost.core.task_id_logger import TaskIdLogger
 from funboost.constant import FunctionKind
 
@@ -448,10 +448,10 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         """
         raise NotImplementedError
 
-    def convert_msg_before_run(self, msg: typing.Union[str, dict]) -> dict:
+    def _convert_msg_before_run(self, msg: typing.Union[str, dict]) -> dict:
         """
         转换消息,消息没有使用funboost来发送,并且没有extra相关字段时候
-        用户也可以按照4.21文档,继承任意Consumer类,并实现这个方法 convert_msg_before_run,先转换不规范的消息.
+        用户也可以按照4.21文档,继承任意Consumer类,并实现方法 _user_convert_msg_before_run,先转换不规范的消息.
         """
         """ 一般消息至少包含这样
         {
@@ -469,6 +469,7 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         extra_params = {'task_id': task_id, 'publish_time': round(time.time(), 4),
                         'publish_time_format': time.strftime('%Y-%m-%d %H:%M:%S')}
         """
+        msg = self._user_convert_msg_before_run(msg)
         msg = Serialization.to_dict(msg)
         # 以下是清洗补全字段.
         if 'extra' not in msg:
@@ -481,10 +482,17 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         if 'publish_time_format':
             extra['publish_time_format'] = MsgGenerater.generate_publish_time_format()
         return msg
+    
+    def _user_convert_msg_before_run(self, msg: typing.Union[str, dict]) -> dict:
+        """
+        用户也可以提前清洗数据
+        """
+        # print(msg)
+        return msg
 
     def _submit_task(self, kw):
 
-        kw['body'] = self.convert_msg_before_run(kw['body'])
+        kw['body'] = self._convert_msg_before_run(kw['body'])
         self._print_message_get_from_broker(kw['body'])
         if self._judge_is_daylight():
             self._requeue(kw)
@@ -635,8 +643,9 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
     async def aio_user_custom_record_process_info_func(self, current_function_result_status: FunctionResultStatus):  # 这个可以继承
         pass
 
-    def _convert_real_function_only_params_by_conusuming_function_kind(self, function_only_params: dict):
+    def _convert_real_function_only_params_by_conusuming_function_kind(self, function_only_params: dict,extra_params:dict):
         """对于实例方法和classmethod 方法， 从消息队列的消息恢复第一个入参， self 和 cls"""
+        can_not_json_serializable_keys = extra_params.get('can_not_json_serializable_keys',[])
         if self.consumer_params.consuming_function_kind in [FunctionKind.CLASS_METHOD, FunctionKind.INSTANCE_METHOD]:
             real_function_only_params = copy.copy(function_only_params)
             method_first_param_name = None
@@ -658,8 +667,14 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
                 obj = method_cls(**method_first_param_value[ConstStrForClassMethod.OBJ_INIT_PARAMS])
                 real_function_only_params[method_first_param_name] = obj
             # print(real_function_only_params)
+            if can_not_json_serializable_keys:
+                for key in can_not_json_serializable_keys:
+                    real_function_only_params[key] = PickleHelper.to_obj(real_function_only_params[key])
             return real_function_only_params
         else:
+            if can_not_json_serializable_keys:
+                for key in can_not_json_serializable_keys:
+                    function_only_params[key] = PickleHelper.to_obj(function_only_params[key])
             return function_only_params
 
     # noinspection PyProtectedMember
@@ -758,7 +773,7 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
                     self.logger.warning(f'取消运行 {task_id} {function_only_params}')
                     return function_result_status
                 function_run = kill_remote_task.kill_fun_deco(task_id)(function_run)  # 用杀死装饰器包装起来在另一个线程运行函数,以便等待远程杀死。
-            function_result_status.result = function_run(**self._convert_real_function_only_params_by_conusuming_function_kind(function_only_params))
+            function_result_status.result = function_run(**self._convert_real_function_only_params_by_conusuming_function_kind(function_only_params,kw['body']['extra']))
             # if asyncio.iscoroutine(function_result_status.result):
             #     log_msg = f'''异步的协程消费函数必须使用 async 并发模式并发,请设置消费函数 {self.consuming_function.__name__} 的concurrent_mode 为 ConcurrentModeEnum.ASYNC 或 4'''
             #     # self.logger.critical(msg=f'{log_msg} \n')
@@ -813,6 +828,9 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
             self.logger.error(msg=log_msg, exc_info=self._get_priority_conf(kw, 'is_print_detail_exception'))
             # traceback.print_exc()
             function_result_status.exception = f'{e.__class__.__name__}    {str(e)}'
+            function_result_status.exception_msg = str(e)
+            function_result_status.exception_type = e.__class__.__name__
+
             function_result_status.result = FunctionResultStatus.FUNC_RUN_ERROR
         return function_result_status
 
@@ -899,7 +917,7 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
                                  logger=self.logger,queue_name=self.queue_name,)
         fct.set_fct_context(fct_context)
         try:
-            corotinue_obj = self.consuming_function(**self._convert_real_function_only_params_by_conusuming_function_kind(function_only_params))
+            corotinue_obj = self.consuming_function(**self._convert_real_function_only_params_by_conusuming_function_kind(function_only_params,kw['body']['extra']))
             if not asyncio.iscoroutine(corotinue_obj):
                 log_msg = f'''当前设置的并发模式为 async 并发模式，但消费函数不是异步协程函数，请不要把消费函数 {self.consuming_function.__name__} 的 concurrent_mode 设置错误'''
                 # self.logger.critical(msg=f'{log_msg} \n')
@@ -946,6 +964,8 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
             # self.error_file_logger.error(msg=f'{log_msg} \n', exc_info=self._get_priority_conf(kw, 'is_print_detail_exception'))
             self.logger.error(msg=log_msg, exc_info=self._get_priority_conf(kw, 'is_print_detail_exception'))
             function_result_status.exception = f'{e.__class__.__name__}    {str(e)}'
+            function_result_status.exception_msg = str(e)
+            function_result_status.exception_type = e.__class__.__name__
             function_result_status.result = FunctionResultStatus.FUNC_RUN_ERROR
         return function_result_status
 
@@ -1106,7 +1126,9 @@ class ConcurrentModeDispatcher(FunboostFileLoggerMixin):
         # pool_type = ProcessPoolExecutor
         if self._concurrent_mode == ConcurrentModeEnum.ASYNC:
             self.consumer._concurrent_pool = self.consumer.consumer_params.specify_concurrent_pool or pool_type(
-                self.consumer.consumer_params.concurrent_num, loop=self.consumer.consumer_params.specify_async_loop)
+                self.consumer.consumer_params.concurrent_num,
+                  specify_async_loop=self.consumer.consumer_params.specify_async_loop,
+                  is_auto_start_specify_async_loop_in_child_thread=self.consumer.consumer_params.is_auto_start_specify_async_loop_in_child_thread)
         else:
             # print(pool_type)
             self.consumer._concurrent_pool = self.consumer.consumer_params.specify_concurrent_pool or pool_type(self.consumer.consumer_params.concurrent_num)

funboost/consumers/faststream_consumer.py

@@ -22,7 +22,7 @@ class FastStreamConsumer(EmptyConsumer):
             # print(logger.name)
             # return self.consuming_function(*args, **kwargs) # 如果没有声明 autoretry_for ，那么消费函数出错了就不会自动重试了。
             # print(msg)
-            function_only_params = delete_keys_and_return_new_dict(json.loads(msg))
+            function_only_params = delete_keys_and_return_new_dict(Serialization.to_dict(msg))
             if self._consuming_function_is_asyncio:
                 result = await self.consuming_function(**function_only_params)
             else:

funboost/consumers/http_consumer.py

@@ -10,20 +10,25 @@ import json
 from funboost.consumers.base_consumer import AbstractConsumer
 from funboost.core.lazy_impoter import AioHttpImporter
 
+
 class HTTPConsumer(AbstractConsumer, ):
     """
     http 实现消息队列，不支持持久化，但不需要安装软件。
     """
-
+    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
+        # 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):

funboost/consumers/kafka_consumer_manually_commit.py

@@ -72,8 +72,6 @@ class KafkaConsumerManuallyCommit(AbstractConsumer):
                     f'从kafka的 [{self._queue_name}] 主题,分区 {msg.partition()} 中 的 offset {msg.offset()} 取出的消息是：  {msg.value()}')  # noqa
             self._submit_task(kw)
 
-            # kw = {'consumer': consumer, 'message': message, 'body': json.loads(message.value)}
-            # self._submit_task(kw)
 
     def _manually_commit(self):
         """

funboost/consumers/tcp_consumer.py

@@ -13,32 +13,34 @@ class TCPConsumer(AbstractConsumer, ):
     socket 实现消息队列，不支持持久化，但不需要安装软件。
     """
 
-
-    BUFSIZE = 10240
+    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'host': '127.0.0.1', 'port': None, 'bufsize': 10240}
 
     # noinspection PyAttributeOutsideInit
     def custom_init(self):
-        ip__port_str = self.queue_name.split(':')
-        ip_port = (ip__port_str[0], int(ip__port_str[1]))
-        self._ip_port_raw = ip_port
-        self._ip_port = ('', ip_port[1])
+        # ip__port_str = self.queue_name.split(':')
+        # ip_port = (ip__port_str[0], int(ip__port_str[1]))
+        # self._ip_port_raw = ip_port
+        # self._ip_port = ('', ip_port[1])
         # ip_port = ('', 9999)
+        self._ip_port = (self.consumer_params.broker_exclusive_config['host'],
+                         self.consumer_params.broker_exclusive_config['port'])
+        self.bufsize = self.consumer_params.broker_exclusive_config['bufsize']
 
     # noinspection DuplicatedCode
     def _shedual_task(self):
-        """ tcp为消息队列中间件 时候 queue_name 要设置为例如  127.0.0.1:5689"""
+      
         server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  # tcp协议
         server.bind(self._ip_port)
         server.listen(128)
         self._server = server
         while True:
             tcp_cli_sock, addr = self._server.accept()
-            Thread(target=self.__handle_conn, args=(tcp_cli_sock,)).start() # 服务端多线程，可以同时处理多个tcp长链接客户端发来的消息。
+            Thread(target=self.__handle_conn, args=(tcp_cli_sock,)).start()  # 服务端多线程，可以同时处理多个tcp长链接客户端发来的消息。
 
     def __handle_conn(self, tcp_cli_sock):
         try:
             while True:
-                data = tcp_cli_sock.recv(self.BUFSIZE)
+                data = tcp_cli_sock.recv(self.bufsize)
                 # print('server收到的数据', data)
                 if not data:
                     break
@@ -56,4 +58,3 @@ class TCPConsumer(AbstractConsumer, ):
 
     def _requeue(self, kw):
         pass
-

funboost/consumers/udp_consumer.py

@@ -12,14 +12,17 @@ class UDPConsumer(AbstractConsumer, ):
     socket 实现消息队列，不支持持久化，但不需要安装软件。
     """
 
-    BUFSIZE = 10240
+    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'host': '127.0.0.1', 'port': None, 'bufsize': 10240}
 
     # noinspection PyAttributeOutsideInit
     def custom_init(self):
-        """ udp为消息队列中间件 时候 queue_name 要设置为例如  127.0.0.1:5689"""
+        
         self.__udp_client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-        ip__port_str = self.queue_name.split(':')
-        self.__ip_port = (ip__port_str[0], int(ip__port_str[1]))
+        # ip__port_str = self.queue_name.split(':')
+        # self.__ip_port = (ip__port_str[0], int(ip__port_str[1]))
+        self.__ip_port = (self.consumer_params.broker_exclusive_config['host'],
+                          self.consumer_params.broker_exclusive_config['port'])
+        self._bufsize = self.consumer_params.broker_exclusive_config['bufsize']
         self.__udp_client.connect(self.__ip_port)
 
     # noinspection DuplicatedCode
@@ -29,7 +32,7 @@ class UDPConsumer(AbstractConsumer, ):
         server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  # udp协议
         server.bind(ip_port)
         while True:
-            data, client_addr = server.recvfrom(self.BUFSIZE)
+            data, client_addr = server.recvfrom(self._bufsize)
             # print('server收到的数据', data)
             # self._print_message_get_from_broker(f'udp {ip_port}', data.decode())
             server.sendto('has_recived'.encode(), client_addr)
@@ -41,4 +44,4 @@ class UDPConsumer(AbstractConsumer, ):
 
     def _requeue(self, kw):
         self.__udp_client.send(json.dumps(kw['body']).encode())
-        data = self.__udp_client.recv(self.BUFSIZE)
+        data = self.__udp_client.recv(self._bufsize)

funboost/consumers/zeromq_consumer.py

@@ -67,31 +67,38 @@ class ZeroMqConsumer(AbstractConsumer):
     zeromq 中间件的消费者，zeromq基于socket代码，不会持久化，且不需要安装软件。
     """
 
-    def start_broker_queue_name_as_port(self):
+    BROKER_EXCLUSIVE_CONFIG_DEFAULT = {'port': None}
+
+    def custom_init(self):
+        self._port = self.consumer_params.broker_exclusive_config['port']
+        if self._port is None:
+            raise ValueError('please specify port')
+
+    def _start_broker_port(self):
         # threading.Thread(target=self._start_broker).start()
         # noinspection PyBroadException
         try:
-            if not (10000 < int(self._queue_name) < 65535):
-                raise ValueError("，请设置queue的名字是一个 10000到65535的之间的一个端口数字")
+            if not (10000 < int(self._port) < 65535):
+                raise ValueError("请设置port是一个 10000到65535的之间的一个端口数字")
         except BaseException:
-            self.logger.critical(f" zeromq 模式以 queue 的民资作为tcp 端口，请设置queue的名字是一个 10000 到 65535 之间的一个端口数字")
+            self.logger.critical(f" 请设置port是一个 10000到65535的之间的一个端口数字")
             # noinspection PyProtectedMember
             os._exit(444)
-        if check_port_is_used('127.0.0.1', int(self._queue_name)):
-            self.logger.debug(f"""{int(self._queue_name)} router端口已经启动(或占用) """)
+        if check_port_is_used('127.0.0.1', int(self._port)):
+            self.logger.debug(f"""{int(self._port)} router端口已经启动(或占用) """)
             return
-        if check_port_is_used('127.0.0.1', int(self._queue_name) + 1):
-            self.logger.debug(f"""{int(self._queue_name) + 1} dealer 端口已经启动(或占用) """)
+        if check_port_is_used('127.0.0.1', int(self._port) + 1):
+            self.logger.debug(f"""{int(self._port) + 1} dealer 端口已经启动(或占用) """)
             return
-        multiprocessing.Process(target=start_broker, args=(int(self._queue_name), int(self._queue_name) + 1)).start()
+        multiprocessing.Process(target=start_broker, args=(int(self._port), int(self._port) + 1)).start()
 
     # noinspection DuplicatedCode
     def _shedual_task(self):
-        self.start_broker_queue_name_as_port()
+        self._start_broker_port()
         context = ZmqImporter().zmq.Context()
         # noinspection PyUnresolvedReferences
         zsocket = context.socket(ZmqImporter().zmq.REP)
-        zsocket.connect(f"tcp://localhost:{int(self._queue_name) + 1}")
+        zsocket.connect(f"tcp://localhost:{int(self._port) + 1}")
 
         while True:
             message = zsocket.recv()

funboost/core/exceptions.py

@@ -11,6 +11,11 @@ class ExceptionForRetry(FunboostException):
 class ExceptionForRequeue(FunboostException):
     """框架检测到此错误，重新放回当前队列中"""
 
+class FunboostWaitRpcResultTimeout(FunboostException):
+    """等待rpc结果超过了指定时间"""
+
+class FunboostRpcResultError(FunboostException):
+    """rpc结果是错误状态"""
 
 class ExceptionForPushToDlxqueue(FunboostException):
     """框架检测到ExceptionForPushToDlxqueue错误，发布到死信队列"""
@@ -40,3 +45,5 @@ def f(x):
 
     def __str__(self):
         return self.new_version_change_hint
+
+

funboost/core/func_params_model.py

@@ -109,8 +109,8 @@ class FunctionResultStatusPersistanceConfig(BaseJsonAbleModel):
             flogger.warning(f'你设置的过期时间为 {value} ,设置的时间过长。 ')
         return value
 
-    @root_validator(skip_on_failure=True,allow_reuse=True)
-    def cehck_values(cls, values: dict):
+    @root_validator(skip_on_failure=True)
+    def check_values(cls, values: dict):
         if not values['is_save_status'] and values['is_save_result']:
             raise ValueError(f'你设置的是不保存函数运行状态但保存函数运行结果。不允许你这么设置')
         return values
@@ -134,7 +134,9 @@ class BoosterParams(BaseJsonAbleModel):
     concurrent_mode: str = ConcurrentModeEnum.THREADING  # 并发模式,支持THREADING,GEVENT,EVENTLET,ASYNC,SINGLE_THREAD并发,multi_process_consume 支持协程/线程 叠加多进程并发,性能炸裂.
     concurrent_num: int = 50  # 并发数量，并发种类由concurrent_mode决定
     specify_concurrent_pool: typing.Optional[FunboostBaseConcurrentPool] = None  # 使用指定的线程池/携程池，可以多个消费者共使用一个线程池,节约线程.不为None时候。threads_num失效
+    
     specify_async_loop: typing.Optional[asyncio.AbstractEventLoop] = None  # 指定的async的loop循环，设置并发模式为async才能起作用。 有些包例如aiohttp,发送请求和httpclient的实例化不能处在两个不同的loop中,可以传过来.
+    is_auto_start_specify_async_loop_in_child_thread: bool = True  # 是否在子线程中自动启动指定的async的loop循环，设置并发模式为async才能起作用。如果是False,用户自己在自己的代码中去手动启动自己的loop.run_forever() 
 
     """qps:
     强悍的控制功能,指定1秒内的函数执行次数，例如可以是小数0.01代表每100秒执行一次，也可以是50代表1秒执行50次.为None则不控频。 设置qps时候,不需要指定并发数量,funboost的能够自适应智能动态调节并发池大小."""
@@ -159,10 +161,18 @@ class BoosterParams(BaseJsonAbleModel):
     consumin_function_decorator: typing.Optional[typing.Callable] = None  # 函数的装饰器。因为此框架做参数自动转指点，需要获取精准的入参名称，不支持在消费函数上叠加 @ *args  **kwargs的装饰器，如果想用装饰器可以这里指定。
     function_timeout: typing.Union[int, float,None] = None  # 超时秒数，函数运行超过这个时间，则自动杀死函数。为0是不限制。 谨慎使用,非必要别去设置超时时间,设置后性能会降低(因为需要把用户函数包装到另一个线单独的程中去运行),而且突然强制超时杀死运行中函数,可能会造成死锁.(例如用户函数在获得线程锁后突然杀死函数,别的线程再也无法获得锁了)
 
-    log_level: int = logging.DEBUG  # 消费者和发布者的日志级别,建议设置DEBUG级别,不然无法知道正在运行什么消息
+    """
+    log_level:
+        logger_name 对应的 日志级别
+        消费者和发布者的日志级别,建议设置DEBUG级别,不然无法知道正在运行什么消息.
+        这个是funboost每个队列的单独命名空间的日志级别,丝毫不会影响改变用户其他日志以及root命名空间的日志级别,所以DEBUG级别就好,
+        用户不要压根不懂什么是python logger 的name,还去手痒调高级别. 
+        不懂python日志命名空间的小白去看nb_log文档,或者直接问 ai大模型 python logger name的作用是什么.
+    """
+    log_level: int = logging.DEBUG # 不需要改这个级别,请看上面原因
     logger_prefix: str = ''  # 日志名字前缀,可以设置前缀
     create_logger_file: bool = True  # 发布者和消费者是否创建文件文件日志,为False则只打印控制台不写文件.
-    logger_name: str = ''  # 队列消费者发布者的日志命名空间.
+    logger_name: typing.Union[str, None] = ''  # 队列消费者发布者的日志命名空间.
     log_filename: typing.Union[str, None] = None  # 消费者发布者的文件日志名字.如果为None,则自动使用 funboost.队列 名字作为文件日志名字.  日志文件夹是在nb_log_config.py的 LOG_PATH中决定的.
     is_show_message_get_from_broker: bool = False  # 运行时候,是否记录从消息队列获取出来的消息内容
     is_print_detail_exception: bool = True  # 消费函数出错时候,是否打印详细的报错堆栈,为False则只打印简略的报错信息不包含堆栈.
@@ -221,7 +231,7 @@ class BoosterParams(BaseJsonAbleModel):
 
 
 
-    @root_validator(skip_on_failure=True)
+    @root_validator(skip_on_failure=True, )
     def check_values(cls, values: dict):
        
 
@@ -307,7 +317,7 @@ class PriorityConsumingControlConfig(BaseJsonAbleModel):
     eta: typing.Union[datetime.datetime, str,None] = None  # 时间对象， 或 %Y-%m-%d %H:%M:%S 字符串。
     misfire_grace_time: typing.Union[int, None] = None
 
-    other_extra_params: dict = None  # 其他参数, 例如消息优先级 , priority_control_config=PriorityConsumingControlConfig(other_extra_params={'priroty': priorityxx})，
+    other_extra_params: typing.Optional[dict] = None  # 其他参数, 例如消息优先级 , priority_control_config=PriorityConsumingControlConfig(other_extra_params={'priroty': priorityxx})，
     
     """filter_str:
     用户指定过滤字符串， 例如函数入参是 def fun(userid,username,sex，user_description),
@@ -318,6 +328,7 @@ class PriorityConsumingControlConfig(BaseJsonAbleModel):
     """
     filter_str :typing.Optional[str] = None 
 
+    can_not_json_serializable_keys: typing.List[str] = None # 不能json序列化的入参名字，反序列化时候需要使用pickle来反序列化这些字段(这个是自动生成的，用户不需要手动指定此入参。)
     @root_validator(skip_on_failure=True)
     def cehck_values(cls, values: dict):
         if values['countdown'] and values['eta']:
@@ -356,4 +367,4 @@ if __name__ == '__main__':
     # print(PriorityConsumingControlConfig().get_str_dict())
 
     print(BoosterParams(queue_name='3213', specify_concurrent_pool=FlexibleThreadPool(100)).json_pre())
-    print(PublisherParams.schema_json())
+    # print(PublisherParams.schema_json())  # 注释掉，因为 PublisherParams 包含 Callable 类型字段，无法生成 JSON Schema

funboost/core/function_result_status_saver.py

@@ -51,6 +51,9 @@ class FunctionResultStatus():
         self.result = None
         self.run_times = 0
         self.exception = None
+        self.exception_type = None
+        self.exception_msg = None
+        self.rpc_chain_error_msg_dict:dict  = None
         self.time_start = time.time()
         self.time_cost = None
         self.time_end = None
@@ -62,6 +65,15 @@ class FunctionResultStatus():
         self._has_kill_task = False
         self.rpc_result_expire_seconds = None
 
+    @classmethod
+    def parse_status_and_result_to_obj(cls,status_dict:dict):
+        obj = cls(status_dict['queue_name'],status_dict['function'],status_dict['msg_dict'])
+        for k,v in status_dict.items():
+            # if k.startswith('_'):
+            #     continue
+            setattr(obj,k,v)
+        return obj
+
     def get_status_dict(self, without_datetime_obj=False):
         self.time_end = time.time()
         if self.run_status == RunStatus.running:
@@ -102,6 +114,9 @@ class FunctionResultStatus():
     def __str__(self):
         return f'''{self.__class__}   {Serialization.to_json_str(self.get_status_dict())}'''
 
+    def to_pretty_json_str(self):
+        return json.dumps(self.get_status_dict(),indent=4,ensure_ascii=False)
+
 
 class ResultPersistenceHelper(MongoMixin, FunboostFileLoggerMixin):
     TASK_STATUS_DB = 'task_status'

funboost/core/msg_result_getter.py

@@ -12,13 +12,29 @@ from funboost.utils.redis_manager import RedisMixin
 from funboost.utils.redis_manager import AioRedisMixin
 from funboost.core.serialization import Serialization
 
+from funboost.core.function_result_status_saver import FunctionResultStatus
+
 class HasNotAsyncResult(Exception):
     pass
 
 
 NO_RESULT = 'no_result'
 
-
+def _judge_rpc_function_result_status_obj(status_and_result_obj:FunctionResultStatus,raise_exception:bool):
+    if status_and_result_obj is None:
+        raise FunboostWaitRpcResultTimeout(f'等待 {status_and_result_obj.task_id} rpc结果超过了指定时间')
+    if status_and_result_obj.success is True:
+        return status_and_result_obj
+    else:
+        raw_erorr = status_and_result_obj.exception
+        if status_and_result_obj.exception_type == 'FunboostRpcResultError':
+            raw_erorr = json.loads(status_and_result_obj.exception_msg) # 使canvas链式报错json显示更美观
+        error_msg_dict = {'task_id':status_and_result_obj.task_id,'raw_error':raw_erorr}
+        if raise_exception:
+            raise FunboostRpcResultError(json.dumps(error_msg_dict,indent=4,ensure_ascii=False))
+        else:
+            status_and_result_obj.rpc_chain_error_msg_dict = error_msg_dict
+            return status_and_result_obj
 class AsyncResult(RedisMixin):
     default_callback_run_executor = FlexibleThreadPoolMinWorkers0(200,work_queue_maxsize=50)
 
@@ -63,6 +79,14 @@ class AsyncResult(RedisMixin):
                 return self._status_and_result
             return None
         return self._status_and_result
+    
+    @property
+    def status_and_result_obj(self) -> FunctionResultStatus:
+        """这个是为了比字典有更好的ide代码补全效果"""
+        if self.status_and_result is not None:
+            return FunctionResultStatus.parse_status_and_result_to_obj(self.status_and_result)
+    
+    rpc_data =status_and_result_obj
 
     def get(self):
         # print(self.status_and_result)
@@ -104,6 +128,14 @@ class AsyncResult(RedisMixin):
             async_result.set_callback(show_result) # 使用回调函数在线程池中并发的运行函数结果
         '''
         self.callback_run_executor.submit(self._run_callback_func, callback_func)
+    
+    def wait_rpc_data_or_raise(self,raise_exception:bool=True)->FunctionResultStatus:
+        return _judge_rpc_function_result_status_obj(self.status_and_result_obj,raise_exception)
+    
+    @classmethod
+    def batch_wait_rpc_data_or_raise(cls,r_list:typing.List['AsyncResult'],raise_exception:bool=True)->typing.List[FunctionResultStatus]:
+        return [ _judge_rpc_function_result_status_obj(r.status_and_result_obj,raise_exception) 
+                for r in r_list]
 
 
 class AioAsyncResult(AioRedisMixin):
@@ -169,6 +201,14 @@ if __name__ == '__main__':
             return None
         return self._status_and_result
 
+    @property
+    async def status_and_result_obj(self) -> FunctionResultStatus:
+        """这个是为了比字典有更好的ide代码补全效果"""
+        sr = await self.status_and_result
+        if sr is not None:
+            return FunctionResultStatus.parse_status_and_result_to_obj(sr)
+
+    rpc_data =status_and_result_obj
     async def get(self):
         # print(self.status_and_result)
         if (await self.status_and_result) is not None:
@@ -192,6 +232,16 @@ if __name__ == '__main__':
     async def set_callback(self, aio_callback_func: typing.Callable):
         asyncio.create_task(self._run_callback_func(callback_func=aio_callback_func))
 
+    async def wait_rpc_data_or_raise(self,raise_exception:bool=True)->FunctionResultStatus:
+        return _judge_rpc_function_result_status_obj(await self.status_and_result_obj,raise_exception)
+
+    @classmethod
+    async def batch_wait_rpc_data_or_raise(cls,r_list:typing.List['AioAsyncResult'],raise_exception:bool=True)->typing.List[FunctionResultStatus]:
+        return [ _judge_rpc_function_result_status_obj(await r.status_and_result_obj,raise_exception) 
+                for r in r_list]
+    
+
+
 
 class ResultFromMongo(MongoMixin):
     """