funboost 44.8__py3-none-any.whl → 45.0__py3-none-any.whl

funboost/__init__.py

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

funboost/constant.py

@@ -1,6 +1,6 @@
 # coding= utf-8
 class BrokerEnum:
-    EMPTY = 'empty' # 空的实现，需要搭配 boost入参的 consumer_override_cls 和 publisher_override_cls使用，或者被继承。
+    EMPTY = 'empty'  # 空的实现，需要搭配 boost入参的 consumer_override_cls 和 publisher_override_cls使用，或者被继承。
 
     RABBITMQ_AMQPSTORM = 'RABBITMQ_AMQPSTORM'  # 使用 amqpstorm 包操作rabbitmq  作为 分布式消息队列，支持消费确认.强烈推荐这个作为funboost中间件。
     RABBITMQ = RABBITMQ_AMQPSTORM
@@ -41,8 +41,6 @@ class BrokerEnum:
 
     ZEROMQ = 'ZEROMQ'  # 基于zeromq作为分布式消息队列，不需要安装中间件，可以支持跨机器但不支持持久化。
 
-
-
     """
     操作 kombu 包，这个包也是celery的中间件依赖包，这个包可以操作10种中间件(例如rabbitmq redis)，但没包括分布式函数调度框架的kafka nsq zeromq 等。
     同时 kombu 包的性能非常差，可以用原生redis的lpush和kombu的publish测试发布，使用brpop 和 kombu 的 drain_events测试消费，对比差距相差了5到10倍。
@@ -71,7 +69,6 @@ class BrokerEnum:
 
     PEEWEE = 'PEEWEE'  # peewee包操作mysql，使用表模拟消息队列
 
-
     CELERY = 'CELERY'  # funboost支持celery框架来发布和消费任务，由celery框架来调度执行任务，但是写法简单远远暴击用户亲自使用celery的麻烦程度，
     # 用户永无无需关心和操作Celery对象实例,无需关心celery的task_routes和include配置,funboost来自动化设置这些celery配置。
 
@@ -92,4 +89,17 @@ class ConcurrentModeEnum:
     SINGLE_THREAD = 'single_thread'  # 如果你不想并发，不想预先从消息队列中间件拉取消息到python程序的内存queue队列缓冲中，那么就适合使用此并发模式。
     SOLO = SINGLE_THREAD
 
+
 # is_fsdf_remote_run = 0
+
+class FunctionKind:
+    CLASS_METHOD = 'CLASS_METHOD'
+    INSTANCE_METHOD = 'INSTANCE_METHOD'
+    STATIC_METHOD = 'STATIC_METHOD'
+    COMMON_FUNCTION = 'COMMON_FUNCTION'
+
+
+class ConstStrForClassMethod:
+    FIRST_PARAM_NAME = 'first_param_name'
+    CLS_NAME = 'cls_name'
+    OBJ_INIT_PARAMS = 'obj_init_params'

funboost/consumers/base_consumer.py

@@ -8,6 +8,7 @@
 框架做主要的功能都是在这个文件里面实现的.
 """
 import functools
+import sys
 import typing
 import abc
 import copy
@@ -30,13 +31,14 @@ from threading import Lock
 import asyncio
 
 import nb_log
-from funboost.core.current_task import funboost_current_task
+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.task_id_logger import TaskIdLogger
+from funboost.constant import FunctionKind
 from funboost.utils.json_helper import JsonUtils
-from nb_log import (get_logger, LoggerLevelSetterMixin, LogManager,  is_main_process,
+from nb_log import (get_logger, LoggerLevelSetterMixin, LogManager, is_main_process,
                     nb_log_config_default)
 from funboost.core.loggers import FunboostFileLoggerMixin, logger_prompt
 
@@ -66,7 +68,7 @@ from funboost.consumers.redis_filter import RedisFilter, RedisImpermanencyFilter
 from funboost.factories.publisher_factotry import get_publisher
 
 from funboost.utils import decorators, time_util, redis_manager
-from funboost.constant import ConcurrentModeEnum, BrokerEnum
+from funboost.constant import ConcurrentModeEnum, BrokerEnum, ConstStrForClassMethod
 from funboost.core import kill_remote_task
 from funboost.core.exceptions import ExceptionForRequeue, ExceptionForPushToDlxqueue
 
@@ -562,12 +564,35 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         """
         self._do_not_delete_extra_from_msg = True
 
-    def user_custom_record_process_info_func(self,current_function_result_status:FunctionResultStatus):  # 这个可以继承
+    def user_custom_record_process_info_func(self, current_function_result_status: FunctionResultStatus):  # 这个可以继承
         pass
 
-    async def aio_user_custom_record_process_info_func(self,current_function_result_status:FunctionResultStatus):  # 这个可以继承
+    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):
+        """对于实例方法和classmethod 方法， 从消息队列的消息恢复第一个入参， self 和 cls"""
+        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
+            method_first_param_value = None
+            for k, v in function_only_params.items():
+                if isinstance(v, dict) and ConstStrForClassMethod.FIRST_PARAM_NAME in v:
+                    method_first_param_name = k
+                    method_first_param_value = v
+                    break
+            method_cls = getattr(sys.modules[self.consumer_params.consuming_function_class_module],
+                                 self.consumer_params.consuming_function_class_name)
+            if self.publisher_params.consuming_function_kind == FunctionKind.CLASS_METHOD:
+                real_function_only_params[method_first_param_name] = method_cls
+            elif self.publisher_params.consuming_function_kind == FunctionKind.INSTANCE_METHOD:
+                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)
+            return real_function_only_params
+        else:
+            return function_only_params
+
     # noinspection PyProtectedMember
     def _run(self, kw: dict, ):
         # print(kw)
@@ -627,9 +652,9 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
                     msg = f'{self._unit_time_for_count} 秒内执行了 {self._execute_task_times_every_unit_time} 次函数 [ {self.consuming_function.__name__} ] ,' \
                           f'函数平均运行耗时 {avarage_function_spend_time} 秒。 '
                     self.logger.info(msg)
-                    if  time.time() - self._last_show_remaining_execution_time > self._show_remaining_execution_time_interval:
+                    if time.time() - self._last_show_remaining_execution_time > self._show_remaining_execution_time_interval:
                         self._msg_num_in_broker = self.publisher_of_same_queue.get_message_count()
-                        if self._msg_num_in_broker != -1 :  # 有的中间件无法统计或没实现统计队列剩余数量的，统一返回的是-1，不显示这句话。
+                        if self._msg_num_in_broker != -1:  # 有的中间件无法统计或没实现统计队列剩余数量的，统一返回的是-1，不显示这句话。
                             # msg += f''' ，预计还需要 {time_util.seconds_to_hour_minute_second(self._msg_num_in_broker * avarage_function_spend_time / active_consumer_num)} 时间 才能执行完成 {self._msg_num_in_broker}个剩余的任务'''
                             need_time = time_util.seconds_to_hour_minute_second(self._msg_num_in_broker / (self._execute_task_times_every_unit_time / self._unit_time_for_count) /
                                                                                 self._distributed_consumer_statistics.active_consumer_num)
@@ -639,7 +664,7 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
                     self._current_time_for_execute_task_times_every_unit_time = time.time()
                     self._consuming_function_cost_time_total_every_unit_time = 0
                     self._execute_task_times_every_unit_time = 0
-            self.user_custom_record_process_info_func(current_function_result_status) # 两种方式都可以自定义,记录结果,建议继承方式,不使用boost中指定 user_custom_record_process_info_func
+            self.user_custom_record_process_info_func(current_function_result_status)  # 两种方式都可以自定义,记录结果,建议继承方式,不使用boost中指定 user_custom_record_process_info_func
             if self.consumer_params.user_custom_record_process_info_func:
                 self.consumer_params.user_custom_record_process_info_func(current_function_result_status)
         except BaseException as e:
@@ -656,17 +681,19 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         t_start = time.time()
         # function_result_status.run_times = current_retry_times + 1
         fct = funboost_current_task()
-        fct.function_params = function_only_params
-        fct.full_msg = kw['body']
-        fct.function_result_status = function_result_status
-        fct.logger = self.logger
+        fct_context = FctContext(function_params=function_only_params,
+                                 full_msg=kw['body'],
+                                 function_result_status=function_result_status,
+                                 logger=self.logger, )
+
         try:
             function_run = self.consuming_function
             if self._consuming_function_is_asyncio:
-                fct._fct_local_data._asyncio_use_thread_concurrent_mode = True
+                fct_context.asyncio_use_thread_concurrent_mode = True
                 function_run = sync_or_async_fun_deco(function_run)
             else:
-                fct._fct_local_data._asynco_use_thread_concurrent_mode = False
+                fct_context.asynco_use_thread_concurrent_mode = False
+            fct.set_fct_context(fct_context)
             function_timeout = self._get_priority_conf(kw, 'function_timeout')
             function_run = function_run if self.consumer_params.consumin_function_decorator is None else self.consumer_params.consumin_function_decorator(function_run)
             function_run = function_run if not function_timeout else self._concurrent_mode_dispatcher.timeout_deco(
@@ -678,7 +705,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(**function_only_params)
+            function_result_status.result = function_run(**self._convert_real_function_only_params_by_conusuming_function_kind(function_only_params))
             # 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')
@@ -828,12 +855,13 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         # noinspection PyBroadException
         t_start = time.time()
         fct = funboost_current_task()
-        fct.function_params = function_only_params
-        fct.full_msg = kw['body']
-        fct.function_result_status = function_result_status
-        fct.logger = self.logger
+        fct_context = FctContext(function_params=function_only_params,
+                                 full_msg=kw['body'],
+                                 function_result_status=function_result_status,
+                                 logger=self.logger, )
+        fct.set_fct_context(fct_context)
         try:
-            corotinue_obj = self.consuming_function(**function_only_params)
+            corotinue_obj = self.consuming_function(**self._convert_real_function_only_params_by_conusuming_function_kind(function_only_params))
             if not asyncio.iscoroutine(corotinue_obj):
                 log_msg = f'''当前设置的并发模式为 async 并发模式，但消费函数不是异步协程函数，请不要把消费函数 {self.consuming_function.__name__} 的 concurrent_mode 设置错误'''
                 # self.logger.critical(msg=f'{log_msg} \n')

funboost/core/booster.py

@@ -1,11 +1,16 @@
 from __future__ import annotations
 import copy
+import inspect
 import os
+import sys
 import types
 import typing
 
 from funboost.concurrent_pool import FlexibleThreadPool
 from funboost.concurrent_pool.async_helper import simple_run_in_executor
+from funboost.constant import FunctionKind
+from funboost.utils.class_utils import ClsHelper
+
 from funboost.utils.ctrl_c_end import ctrl_c_recv
 from funboost.core.loggers import flogger, develop_logger, logger_prompt
 
@@ -85,6 +90,16 @@ class Booster:
         if len(kwargs) == 0 and len(args) == 1 and isinstance(args[0], typing.Callable):
             consuming_function = args[0]
             self.boost_params.consuming_function = consuming_function
+            # print(consuming_function)
+            # print(ClsHelper.get_method_kind(consuming_function))
+            # print(inspect.getsourcelines(consuming_function))
+            if self.boost_params.consuming_function_kind is None:
+                self.boost_params.consuming_function_kind = ClsHelper.get_method_kind(consuming_function)
+            if self.boost_params.consuming_function_kind in [FunctionKind.CLASS_METHOD,FunctionKind.INSTANCE_METHOD]:
+                if self.boost_params.consuming_function_class_module is None:
+                    self.boost_params.consuming_function_class_module = consuming_function.__module__
+                if self.boost_params.consuming_function_class_name is None:
+                    self.boost_params.consuming_function_class_name = consuming_function.__qualname__.split('.')[0]
             logger_prompt.debug(f''' {self.boost_params.queue_name} booster 配置是 {self.boost_params.json_str_value()}''')
             self.consuming_function = consuming_function
             self.is_decorated_as_consume_function = True

funboost/core/current_task.py

@@ -1,7 +1,10 @@
+import abc
 import contextvars
+from dataclasses import dataclass
 import logging
 import threading
 import asyncio
+
 from funboost.core.function_result_status_saver import FunctionResultStatus
 
 """ 用法例子 
@@ -47,38 +50,55 @@ if __name__ == '__main__':
     """
 
 
-class __ThreadCurrentTask:
+@dataclass
+class FctContext:
     """
-    用于在用户自己函数内部去获取 消息的完整体,当前重试次数等.
+    fct 是 funboost current task 的简写
     """
 
-
-    _fct_local_data = threading.local()
-    _fct_local_data._asyncio_use_thread_concurrent_mode = False
+    function_params: dict
+    full_msg: dict
+    function_result_status: FunctionResultStatus
+    logger: logging.Logger
+    asyncio_use_thread_concurrent_mode: bool = False
+
+# class FctContext:
+#     """
+#     fct 是 funboost current task 的简写
+#     """
+#
+#     def __init__(self, function_params: dict,
+#                  full_msg: dict,
+#                  function_result_status: FunctionResultStatus,
+#                  logger: logging.Logger,
+#                  asyncio_use_thread_concurrent_mode: bool = False):
+#         self.function_params = function_params
+#         self.full_msg = full_msg
+#         self.function_result_status = function_result_status
+#         self.logger = logger
+#         self.asyncio_use_thread_concurrent_mode = asyncio_use_thread_concurrent_mode
+
+
+class _BaseCurrentTask(metaclass=abc.ABCMeta):
+    @abc.abstractmethod
+    def set_fct_context(self, fct_context: FctContext):
+        raise NotImplemented
+
+    @abc.abstractmethod
+    def get_fct_context(self) -> FctContext:
+        raise NotImplemented
 
     @property
     def function_params(self):
-        return self._fct_local_data.function_params
-
-    @function_params.setter
-    def function_params(self, function_params: dict):
-        self._fct_local_data.function_params = function_params
+        return self.get_fct_context().function_params
 
     @property
     def full_msg(self) -> dict:
-        return self._fct_local_data.full_msg
-
-    @full_msg.setter
-    def full_msg(self, full_msg: dict):
-        self._fct_local_data.full_msg = full_msg
+        return self.get_fct_context().full_msg
 
     @property
     def function_result_status(self) -> FunctionResultStatus:
-        return self._fct_local_data.function_result_status
-
-    @function_result_status.setter
-    def function_result_status(self, function_result_status: FunctionResultStatus):
-        self._fct_local_data.function_result_status = function_result_status
+        return self.get_fct_context().function_result_status
 
     @property
     def task_id(self) -> FunctionResultStatus:
@@ -86,68 +106,51 @@ class __ThreadCurrentTask:
 
     @property
     def logger(self) -> logging.Logger:
-        return self._fct_local_data.logger
+        return self.get_fct_context().logger
 
-    @logger.setter
-    def logger(self, logger: logging.Logger):
-        self._fct_local_data.logger = logger
+    def __str__(self):
+        return f'<{self.__class__.__name__} [{self.function_result_status.get_status_dict()}]>'
 
-thread_current_task = __ThreadCurrentTask()
-def is_asyncio_environment():
-    try:
-        loop = asyncio.get_running_loop()
-        return True
-    except RuntimeError as e:
-        return False
 
+class __ThreadCurrentTask(_BaseCurrentTask):
+    """
+    用于在用户自己函数内部去获取 消息的完整体,当前重试次数等.
+    """
 
-class __AsyncioCurrentTask:
-    _function_params = contextvars.ContextVar("function_params")
-    _full_msg = contextvars.ContextVar("full_msg")
-    _function_result_status = contextvars.ContextVar("function_result_status")
-    _logger = contextvars.ContextVar('logger')
+    _fct_local_data = threading.local()
 
-    @property
-    def function_params(self):
-        return self._function_params.get()
+    def set_fct_context(self, fct_context: FctContext):
+        self._fct_local_data.fct_context = fct_context
 
-    @function_params.setter
-    def function_params(self, function_params: dict):
-        self._function_params.set(function_params)
+    def get_fct_context(self) -> FctContext:
+        return self._fct_local_data.fct_context
 
-    @property
-    def full_msg(self) -> dict:
-        return self._full_msg.get()
 
-    @full_msg.setter
-    def full_msg(self, full_msg: dict):
-        self._full_msg.set(full_msg)
+class __AsyncioCurrentTask(_BaseCurrentTask):
+    _fct_context = contextvars.ContextVar('fct_context')
 
-    @property
-    def function_result_status(self) -> FunctionResultStatus:
-        return self._function_result_status.get()
+    def set_fct_context(self, fct_context: FctContext):
+        self._fct_context.set(fct_context)
 
-    @function_result_status.setter
-    def function_result_status(self, function_result_status: FunctionResultStatus):
-        self._function_result_status.set(function_result_status)
+    def get_fct_context(self) -> FctContext:
+        return self._fct_context.get()
 
-    @property
-    def task_id(self) :
-        return self.function_result_status.task_id
 
-    @property
-    def logger(self) -> logging.Logger:
-        return self._logger.get()
+thread_current_task = __ThreadCurrentTask()
+asyncio_current_task = __AsyncioCurrentTask()
 
-    @logger.setter
-    def logger(self, logger: logging.Logger):
-        self._logger.set(logger)
 
-asyncio_current_task = __AsyncioCurrentTask()
+def is_asyncio_environment():
+    try:
+        asyncio.get_running_loop()
+        return True
+    except RuntimeError:
+        return False
+
 
 def funboost_current_task():
     if is_asyncio_environment():
-        if getattr(__ThreadCurrentTask._fct_local_data,'_asyncio_use_thread_concurrent_mode',None) is True:
+        if thread_current_task.get_fct_context().asyncio_use_thread_concurrent_mode is True:
             # 如果用户使用的是默认的ConcurrentModeEnum.THREADING并发模式来运行async def 函数，那么也使用线程获取上下文
             return thread_current_task
         else:
@@ -157,18 +160,34 @@ def funboost_current_task():
 
 
 def get_current_taskid():
-    fct = funboost_current_task()
     # return fct.function_result_status.task_id
     try:
+        fct = funboost_current_task()
         return fct.task_id  # 不在funboost的消费函数里面就获取不到上下文了
-    except (AttributeError,LookupError) as e:
+    except (AttributeError, LookupError) as e:
         # print(e,type(e))
         return 'no_task_id'
 
+
+class FctContextThread(threading.Thread):
+    """
+    这个类自动把当前线程的 线程上下文 自动传递给新开的线程。
+    """
+    def __init__(self, group=None, target=None, name=None,
+                 args=(), kwargs=None, *, daemon=None,
+                 ):
+        threading.Thread.__init__(**locals())
+        self.fct_context = thread_current_task.get_fct_context()
+
+    def run(self):
+        thread_current_task.set_fct_context(self.fct_context)
+        super().run()
+
+
 if __name__ == '__main__':
     print(is_asyncio_environment())
     print()
-    for i in range(100000):
+    for i in range(2):
         funboost_current_task()
-        get_current_taskid()
+        print(get_current_taskid())
     print()

funboost/core/func_params_model.py

@@ -193,6 +193,10 @@ class BoosterParams(BaseJsonAbleModel):
     # func_params_is_pydantic_model: bool = False  # funboost 兼容支持 函数娼还是 pydantic model类型，funboost在发布之前和取出来时候自己转化。
 
     auto_generate_info: dict = {}  # 自动生成的信息,不需要用户主动传参.
+    consuming_function_class:typing.Optional[typing.Type] = None
+    consuming_function_kind :typing.Optional[str]= None  #自动生成的信息,不需要用户主动传参.
+    consuming_function_class_module:typing.Optional[str] = None #自动生成的信息,不需要用户主动传参.
+    consuming_function_class_name: typing.Optional[str] = None #自动生成的信息,不需要用户主动传参.
 
     @root_validator(skip_on_failure=True)
     def check_values(cls, values: dict):
@@ -290,6 +294,10 @@ class PublisherParams(BaseJsonAbleModel):
     publisher_override_cls: typing.Optional[typing.Type] = None
     # func_params_is_pydantic_model: bool = False  # funboost 兼容支持 函数娼还是 pydantic model类型，funboost在发布之前和取出来时候自己转化。
 
+    consuming_function_kind: typing.Optional[str] = None  # 自动生成的信息,不需要用户主动传参.
+    consuming_function_class_module: typing.Optional[str] = None  # 自动生成的信息,不需要用户主动传参.
+    consuming_function_class_name: typing.Optional[str] = None  # 自动生成的信息,不需要用户主动传参.
+
 
 if __name__ == '__main__':
     from funboost.concurrent_pool import FlexibleThreadPool

funboost/publishers/base_publisher.py

@@ -16,6 +16,7 @@ from threading import Lock
 import amqpstorm
 
 import nb_log
+from funboost.constant import ConstStrForClassMethod, FunctionKind
 from funboost.core.func_params_model import PublisherParams, PriorityConsumingControlConfig
 from funboost.core.helper_funs import MsgGenerater
 from funboost.core.loggers import develop_logger
@@ -29,6 +30,8 @@ from funboost.core.task_id_logger import TaskIdLogger
 from funboost.utils import decorators
 from funboost.funboost_config_deafult import BrokerConnConfig, FunboostCommonConfig
 
+
+
 RedisAsyncResult = AsyncResult  # 别名
 RedisAioAsyncResult = AioAsyncResult  # 别名
 
@@ -243,15 +246,31 @@ class AbstractPublisher(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         :param func_kwargs:
         :return:
         """
-        # print(func_args,func_kwargs,self.publish_params_checker.all_arg_name)
+        # print(func_args, func_kwargs, self.publish_params_checker.all_arg_name)
         msg_dict = func_kwargs
         # print(msg_dict)
         # print(self.publish_params_checker.position_arg_name_list)
         # print(func_args)
-        for index, arg in enumerate(func_args):
+        func_args_list = list(func_args)
+        if self.publisher_params.consuming_function_kind == FunctionKind.CLASS_METHOD:
+            # print(self.publish_params_checker.all_arg_name[0])
+            # func_args_list.insert(0, {'first_param_name': self.publish_params_checker.all_arg_name[0],
+            #        'cls_type': ClsHelper.get_classs_method_cls(self.publisher_params.consuming_function).__name__},
+            #                       )
+            func_args_list.insert(0, {ConstStrForClassMethod.FIRST_PARAM_NAME: self.publish_params_checker.all_arg_name[0],
+                                 ConstStrForClassMethod.CLS_NAME: self.publisher_params.consuming_function_class_name,})
+        elif self.publisher_params.consuming_function_kind == FunctionKind.INSTANCE_METHOD:
+            if not hasattr(func_args[0],ConstStrForClassMethod.OBJ_INIT_PARAMS):
+                raise ValueError(f'消费函数 {self.publisher_params.consuming_function} 是实例方法，实例必须有 {ConstStrForClassMethod.OBJ_INIT_PARAMS} 属性')
+            func_args_list[0] = {ConstStrForClassMethod.FIRST_PARAM_NAME: self.publish_params_checker.all_arg_name[0],
+                                 ConstStrForClassMethod.OBJ_INIT_PARAMS: getattr(func_args[0],ConstStrForClassMethod.OBJ_INIT_PARAMS),
+                                 ConstStrForClassMethod.CLS_NAME: self.publisher_params.consuming_function_class_name}
+
+        for index, arg in enumerate(func_args_list):
             # print(index,arg,self.publish_params_checker.position_arg_name_list)
             # msg_dict[self.publish_params_checker.position_arg_name_list[index]] = arg
             msg_dict[self.publish_params_checker.all_arg_name[index]] = arg
+
         # print(msg_dict)
         return self.publish(msg_dict)
 

funboost/set_frame_config.py

@@ -100,7 +100,7 @@ def show_frame_config():
         #             only_print_on_main_process(f'{var_name}:                {var_value}')
         logger_prompt.debug(f'''读取的 BrokerConnConfig 配置是:\n {funboost_config_deafult.BrokerConnConfig().get_pwd_enc_json(indent=4)} ''')
 
-        logger_prompt.debug(f'''读取的 FunboostCommonConfig 配置是:\n  {funboost_config_deafult.FunboostCommonConfig().get_json(indent=None)} ''')
+        logger_prompt.debug(f'''读取的 FunboostCommonConfig 配置是:\n  {funboost_config_deafult.FunboostCommonConfig().get_json(indent=4)} ''')
 
     # only_print_on_main_process(f'读取的 BoostDecoratorDefaultParams 默认 @boost 装饰器入参的默认全局配置是： \n  '
     #                            f'{funboost_config_deafult.BoostDecoratorDefaultParams().get_json()}')
@@ -118,6 +118,7 @@ def use_config_form_funboost_config_module():
     当第一次运行脚本时候，函数调度框架会在你的python当前项目的根目录下 {project_root_path} 下，创建一个名为 funboost_config.py 的文件。
     自动读取配置，会优先读取启动脚本的所在目录 {current_script_path} 的funboost_config.py文件，
     如果没有 {current_script_path}/funboost_config.py 文件，则读取项目根目录 {project_root_path} 下的funboost_config.py做配置。
+    只要 funboost_config.py 在任意 PYTHONPATH 的文件夹下，就能自动读取到。
     在 "{project_root_path}/funboost_config.py:1" 文件中，需要按需重新设置要使用到的中间件的键和值，例如没有使用rabbitmq而是使用redis做中间件，则不需要配置rabbitmq。
     """
     # sys.stdout.write(f'\033[0;33m{time.strftime("%H:%M:%S")}\033[0m  "{__file__}:{sys._getframe().f_lineno}"   \033[0;30;43m{inspect_msg}\033[0m\n')