funboost 44.7__py3-none-any.whl → 44.9__py3-none-any.whl

funboost/__init__.py

@@ -13,7 +13,7 @@ set_frame_config这个模块的 use_config_form_funboost_config_module() 是核
 这段注释说明和使用的用户无关,只和框架开发人员有关.
 '''
 
-__version__ = "44.7"
+__version__ = "44.9"
 
 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,9 +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):  # 这个可以继承
+        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)
@@ -624,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)
@@ -636,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) # 两种方式都可以自定义,记录结果.
+            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:
@@ -653,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(
@@ -675,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')
@@ -804,8 +834,11 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
                 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)  # 两种方式都可以自定义,记录结果.建议使用文档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:
-                await self.consumer_params.user_custom_record_process_info_func(current_function_result_status)
+                self.consumer_params.user_custom_record_process_info_func(current_function_result_status)
+
         except BaseException as e:
             log_msg = f' error 严重错误 {type(e)} {e} '
             # self.logger.critical(msg=f'{log_msg} \n', exc_info=True)
@@ -822,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,69 +106,52 @@ 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:
-            # 如果用户使用的是默认的ConcurrentModeEnum.THREADING并发模式，那么也使用线程获取上下文
+        if thread_current_task.get_fct_context().asyncio_use_thread_concurrent_mode is True:
+            # 如果用户使用的是默认的ConcurrentModeEnum.THREADING并发模式来运行async def 函数，那么也使用线程获取上下文
             return thread_current_task
         else:
             return asyncio_current_task
@@ -161,14 +164,30 @@ def get_current_taskid():
     # return fct.function_result_status.task_id
     try:
         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

@@ -10,6 +10,8 @@ from funboost.concurrent_pool import FunboostBaseConcurrentPool, FlexibleThreadP
 from funboost.constant import ConcurrentModeEnum, BrokerEnum
 from pydantic import BaseModel, validator, root_validator, BaseConfig, Field
 
+from funboost.core.lazy_impoter import funboost_lazy_impoter
+
 
 def _patch_for_pydantic_field_deepcopy():
     from concurrent.futures import ThreadPoolExecutor
@@ -191,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):
@@ -213,6 +219,19 @@ class BoosterParams(BaseJsonAbleModel):
                 raise ValueError(f'{cls.__name__} 的字段新增了父类 BoosterParams 不存在的字段 "{k}"')  # 使 BoosterParams的子类,不能增加字段,只能覆盖字段.
         return values
 
+    def __call__(self, func):
+        """
+        新增加一种语法
+        @BoosterParams(queue_name='q1',qps=2) 这个和 @boost(BoosterParams(queue_name='q1',qps=2)) 写法等效
+
+        @BoosterParams(queue_name='q1',qps=2)
+        def f(a,b):
+            print(a,b)
+        :param func:
+        :return:
+        """
+        return funboost_lazy_impoter.boost(self)(func)
+
 
 class BoosterParamsComplete(BoosterParams):
     """
@@ -275,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/core/lazy_impoter.py

@@ -16,8 +16,14 @@ class FunboostLazyImpoter(SingletonBaseNew):
     @property
     @cached_method_result
     def BoostersManager(self):
-        from funboost.core.booster import BoostersManager
-        return BoostersManager
+        from funboost.core import booster
+        return booster.BoostersManager
+
+    @property
+    @cached_method_result
+    def boost(self):
+        from funboost.core import  booster
+        return booster.boost
 
     # @property
     # @cached_method_result

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')

funboost/utils/class_utils.py

@@ -1,51 +1,101 @@
-#
-#
-# # def get_child_custom_attr(child_cls:type,):
-# #     __dict = child_cls.__dict__
-#
-# def merge_cls(cls1:type,cls2:type):
-#     class Cls(cls2):
-#         pass
-#     for k,v in cls1.__dict__.items():
-#         if k.startswith('__') and k.endswith('__'):
-#             continue
-#         print(k,v)
-#         setattr(Cls,k,v)
-#     return Cls
-#
-#
-# if __name__ == '__main__':
-#     class Parent:
-#         attr1=1
-#         def method_from_parent(self):
-#             print('method_from_parent')
-#
-#         def method_from_parent2(self):
-#             print('method_from_parent2')
-#
-#
-#     class Child(Parent):
-#         attr1=2
-#         attr2=22
-#
-#         def method_from_parent2(self):
-#             print('method_from_parent2chile')
-#         def method_from_child(self:Parent):
-#             print('method_from_child')
-#
-#     class Child2(Parent,Parent):
-#         attr1 = 3
-#
-#     class Child2b(Child2):
-#         attr1 = '2b'
-#
-#
-#     class Child2New(Child2b,Child):
-#         pass
-#
-#
-#     print(Child2().method_from_parent2())
-#     print(Child2New().method_from_parent2())
-#
-#
-#
+import copy
+import gc
+import inspect
+import re
+import sys
+import typing
+
+import nb_log
+from types import MethodType, FunctionType
+
+from funboost.constant import FunctionKind
+
+
+class ClsHelper:
+    @staticmethod
+    def get_instncae_method_cls(instncae_method):
+        print(instncae_method)
+        print(instncae_method.__qualname__)
+        print(instncae_method.__module__)
+        return getattr(sys.modules[instncae_method.__module__],instncae_method.__qualname__.split('.')[0])
+        # return instncae_method.__self__.__class__
+
+    @staticmethod
+    def get_classs_method_cls(class_method):
+        print(class_method)
+        print(class_method.__qualname__)
+        print(class_method.__module__)
+        return getattr(sys.modules[class_method.__module__],class_method.__qualname__.split('.')[0])
+
+    @staticmethod
+    def is_class_method(method):
+        # if inspect.ismethod(method):
+        #     if hasattr(method, '__self__') and inspect.isclass(method.__self__):
+        #         return True
+        # return False
+
+        sourcelines = inspect.getsourcelines(method)
+        # print(sourcelines)
+        line0: str = sourcelines[0][0]
+        if line0.replace(' ', '').startswith('@classmethod'):
+            return True
+
+    @staticmethod
+    def is_static_method(method):
+        sourcelines = inspect.getsourcelines(method)
+        line0: str = sourcelines[0][0]
+        if line0.replace(' ', '').startswith('@staticmethod'):
+            return True
+
+    @classmethod
+    def is_instance_method(cls, method):
+        if cls.is_class_method(method):
+            return False
+        if cls.is_static_method(method):
+            return False
+        if isinstance(method, FunctionType):
+            sourcelines = inspect.getsourcelines(method)
+            for line in sourcelines[0][:50]:
+                if not line.replace( ' ','').startswith('#'):
+                    if not line.startswith('def') and re.search('\(\s*?self\s*?,',line):
+                        return True
+        # method_class = getattr(method, '__qualname__', '').rsplit('.', 1)[0]
+        # if method_class:  # 如果能找到类名，说明是类的成员
+        #     print( f"{method.__name__} 属于类 {method_class} 的成员")
+        #
+        #     return True
+
+    @classmethod
+    def is_common_function(cls, method):
+        if cls.is_static_method(method):
+            return False
+        if cls.is_class_method(method):
+            return False
+        if cls.is_instance_method(method):
+            return False
+        if isinstance(method, FunctionType):
+            sourcelines = inspect.getsourcelines(method)
+            for line in sourcelines[0][:50]:
+                if not line.replace(' ', '').startswith('#'):
+                    if not re.search('\(\s*?self\s*?,', line):
+                        return True
+
+    @classmethod
+    def get_method_kind(cls, method: typing.Callable) -> str:
+        if cls.is_class_method(method):
+            return FunctionKind.CLASS_METHOD
+        elif cls.is_static_method(method):
+            return FunctionKind.STATIC_METHOD
+        elif cls.is_instance_method(method):
+            return FunctionKind.INSTANCE_METHOD
+        elif cls.is_common_function(method):
+            return FunctionKind.COMMON_FUNCTION
+
+    @staticmethod
+    def get_obj_init_params_for_funboost(obj_init_params: dict):
+        obj_init_params.pop('self')
+        return copy.deepcopy(obj_init_params)
+
+
+if __name__ == '__main__':
+    pass

funboost/utils/dependency_packages_in_pythonpath/func_timeout/StoppableThread.py

@@ -9,9 +9,10 @@ import os
 import ctypes
 import threading
 
+from funboost.core.current_task import FctContextThread
 __all__ = ('StoppableThread', 'JoinThread')
 
-class StoppableThread(threading.Thread):
+class StoppableThread(FctContextThread): # 这里重要，继承的是FctContextThread，而不是原生 threading.Thread
     '''
         StoppableThread - A thread that can be stopped by forcing an exception in the execution context.
 
@@ -80,7 +81,7 @@ class StoppableThread(threading.Thread):
         return self._stopThread(exception, raiseEvery)
 
 
-class JoinThread(threading.Thread):
+class JoinThread(FctContextThread):
     '''
         JoinThread - The workhouse that stops the StoppableThread.
 

funboost/utils/dependency_packages_in_pythonpath/func_timeout/dafunc.py

@@ -66,9 +66,9 @@ def func_timeout(timeout, func, args=(), kwargs=None):
 
     from funboost.core.current_task import thread_current_task
 
-    def funcwrap(args2, kwargs2,_fct_local_data_dict):
-        fct = thread_current_task
-        fct._fct_local_data.__dict__.update(_fct_local_data_dict)  # 把funboost的消费线程上下文需要传递到超时线程上下文里面来.
+    def funcwrap(args2, kwargs2,):
+        # fct = thread_current_task
+        # fct.set_fct_context(fct_context)  # 把funboost的消费线程上下文需要传递到超时线程上下文里面来.
         try:
             ret.append( func(*args2, **kwargs2) )
         except FunctionTimedOut:
@@ -86,7 +86,7 @@ def func_timeout(timeout, func, args=(), kwargs=None):
 
 
     # fct = funboost_current_task()
-    thread = StoppableThread(target=funcwrap, args=(args, kwargs,thread_current_task._fct_local_data.__dict__))
+    thread = StoppableThread(target=funcwrap, args=(args, kwargs,))
     thread.daemon = True
 
     thread.start()

funboost/utils/dependency_packages_in_pythonpath/func_timeout/dafunc2222.py

@@ -0,0 +1,244 @@
+
+# vim: set ts=4 sw=4 expandtab :
+
+'''
+    Copyright (c) 2016, 2017 Tim Savannah All Rights Reserved.
+
+    Licensed under the Lesser GNU Public License Version 3, LGPLv3. You should have recieved a copy of this with the source distribution as
+    LICENSE, otherwise it is available at https://github.com/kata198/func_timeout/LICENSE
+'''
+
+import copy
+import functools
+import inspect
+import threading
+import time
+import types
+import sys
+
+
+from .exceptions import FunctionTimedOut
+from .StoppableThread import StoppableThread
+
+
+from .py3_raise import raise_exception
+
+
+from functools import wraps
+
+__all__ = ('func_timeout', 'func_set_timeout')
+
+
+
+
+def func_timeout(timeout, func, args=(), kwargs=None):
+    '''
+        func_timeout - Runs the given function for up to #timeout# seconds.
+
+        Raises any exceptions #func# would raise, returns what #func# would return (unless timeout is exceeded), in which case it raises FunctionTimedOut
+
+        @param timeout <float> - Maximum number of seconds to run #func# before terminating
+
+        @param func <function> - The function to call
+
+        @param args    <tuple> - Any ordered arguments to pass to the function
+
+        @param kwargs  <dict/None> - Keyword arguments to pass to the function.
+
+
+        @raises - FunctionTimedOut if #timeout# is exceeded, otherwise anything #func# could raise will be raised
+
+        If the timeout is exceeded, FunctionTimedOut will be raised within the context of the called function every two seconds until it terminates,
+        but will not block the calling thread (a new thread will be created to perform the join). If possible, you should try/except FunctionTimedOut
+        to return cleanly, but in most cases it will 'just work'.
+
+        @return - The return value that #func# gives
+    '''
+
+    if not kwargs:
+        kwargs = {}
+    if not args:
+        args = ()
+
+    ret = []
+    exception = []
+    isStopped = False
+
+    from funboost.core.current_task import thread_current_task
+
+    def funcwrap(args2, kwargs2,fct_context):
+        fct = thread_current_task
+        fct.set_fct_context(fct_context)  # 把funboost的消费线程上下文需要传递到超时线程上下文里面来.
+        try:
+            ret.append( func(*args2, **kwargs2) )
+        except FunctionTimedOut:
+            # Don't print traceback to stderr if we time out
+            pass
+        except BaseException as e:
+            exc_info = sys.exc_info()
+            if isStopped is False:
+                # Assemble the alternate traceback, excluding this function
+                #  from the trace (by going to next frame)
+                # Pytohn3 reads native from __traceback__,
+                # python2 has a different form for "raise"
+                e.__traceback__ = exc_info[2].tb_next
+                exception.append( e )
+
+
+    # fct = funboost_current_task()
+    thread = StoppableThread(target=funcwrap, args=(args, kwargs,thread_current_task.get_fct_context()))
+    thread.daemon = True
+
+    thread.start()
+    thread.join(timeout)
+
+    stopException = None
+    if thread.is_alive():
+        isStopped = True
+
+        class FunctionTimedOutTempType(FunctionTimedOut):
+            def __init__(self):
+                return FunctionTimedOut.__init__(self, '', timeout, func, args, kwargs)
+
+        FunctionTimedOutTemp = type('FunctionTimedOut' + str( hash( "%d_%d_%d_%d" %(id(timeout), id(func), id(args), id(kwargs))) ), FunctionTimedOutTempType.__bases__, dict(FunctionTimedOutTempType.__dict__))
+
+        stopException = FunctionTimedOutTemp
+        # raise FunctionTimedOut('', timeout, func, args, kwargs)
+        thread._stopThread(stopException)
+        thread.join(min(.1, timeout / 50.0))
+        raise FunctionTimedOut('', timeout, func, args, kwargs)
+    else:
+        # We can still cleanup the thread here..
+        # Still give a timeout... just... cuz..
+        thread.join(.5)
+
+    if exception:
+        raise_exception(exception)
+
+    if ret:
+        return ret[0]
+
+
+def func_set_timeout(timeout, allowOverride=False):
+    '''
+        func_set_timeout - Decorator to run a function with a given/calculated timeout (max execution time).
+            Optionally (if #allowOverride is True), adds a paramater, "forceTimeout", to the
+            function which, if provided, will override the default timeout for that invocation.
+
+            If #timeout is provided as a lambda/function, it will be called
+              prior to each invocation of the decorated function to calculate the timeout to be used
+              for that call, based on the arguments passed to the decorated function.
+
+              For example, you may have a "processData" function whose execution time
+              depends on the number of "data" elements, so you may want a million elements to have a
+              much higher timeout than seven elements.)
+
+            If #allowOverride is True AND a kwarg of "forceTimeout" is passed to the wrapped function, that timeout
+             will be used for that single call.
+
+        @param timeout <float OR lambda/function> -
+
+            **If float:**
+                Default number of seconds max to allow function to execute
+                  before throwing FunctionTimedOut
+
+            **If lambda/function:
+
+                 If a function/lambda is provided, it will be called for every
+                  invocation of the decorated function (unless #allowOverride=True and "forceTimeout" was passed)
+                  to determine the timeout to use based on the arguments to the decorated function.
+
+                    The arguments as passed into the decorated function will be passed to this function.
+                     They either must match exactly to what the decorated function has, OR
+                      if you prefer to get the *args (list of ordered args) and **kwargs ( key : value  keyword args form),
+                      define your calculate function like:
+
+                        def calculateTimeout(*args, **kwargs):
+                            ...
+
+                      or lambda like:
+
+                        calculateTimeout = lambda *args, **kwargs : ...
+
+                    otherwise the args to your calculate function should match exactly the decorated function.
+
+
+        @param allowOverride <bool> Default False, if True adds a keyword argument to the decorated function,
+            "forceTimeout" which, if provided, will override the #timeout. If #timeout was provided as a lambda / function, it
+             will not be called.
+
+        @throws FunctionTimedOut If time alloted passes without function returning naturally
+
+        @see func_timeout
+    '''
+    # Try to be as efficent as possible... don't compare the args more than once
+
+    #  Helps closure issue on some versions of python
+    defaultTimeout = copy.copy(timeout)
+
+    isTimeoutAFunction = bool( issubclass(timeout.__class__, (types.FunctionType, types.MethodType, types.LambdaType, types.BuiltinFunctionType, types.BuiltinMethodType) ) )
+
+    if not isTimeoutAFunction:
+        if not issubclass(timeout.__class__, (float, int)):
+            try:
+                timeout = float(timeout)
+            except:
+                raise ValueError('timeout argument must be a float/int for number of seconds, or a function/lambda which gets passed the function arguments and returns a calculated timeout (as float or int). Passed type: < %s > is not of any of these, and cannot be converted to a float.' %( timeout.__class__.__name__, ))
+
+
+    if not allowOverride and not isTimeoutAFunction:
+        # Only defaultTimeout provided. Simple function wrapper
+        def _function_decorator(func):
+
+            return wraps(func)(lambda *args, **kwargs : func_timeout(defaultTimeout, func, args=args, kwargs=kwargs))
+
+#            def _function_wrapper(*args, **kwargs):
+#                return func_timeout(defaultTimeout, func, args=args, kwargs=kwargs)
+#            return _function_wrapper
+        return _function_decorator
+
+    if not isTimeoutAFunction:
+        # allowOverride is True and timeout is not a function. Simple conditional on every call
+        def _function_decorator(func):
+            def _function_wrapper(*args, **kwargs):
+                if 'forceTimeout' in kwargs:
+                    useTimeout = kwargs.pop('forceTimeout')
+                else:
+                    useTimeout = defaultTimeout
+
+                return func_timeout(useTimeout, func, args=args, kwargs=kwargs)
+
+            return wraps(func)(_function_wrapper)
+        return _function_decorator
+
+
+    # At this point, timeout IS known to be a function.
+    timeoutFunction = timeout
+
+    if allowOverride:
+        # Could use a lambda here... but want traceback to highlight the calculate function,
+        #  and not the invoked function
+        def _function_decorator(func):
+            def _function_wrapper(*args, **kwargs):
+                if 'forceTimeout' in kwargs:
+                    useTimeout = kwargs.pop('forceTimeout')
+                else:
+                    useTimeout = timeoutFunction(*args, **kwargs)
+
+                return func_timeout(useTimeout, func, args=args, kwargs=kwargs)
+
+            return wraps(func)(_function_wrapper)
+        return _function_decorator
+
+    # Cannot override, and calculate timeout function
+    def _function_decorator(func):
+        def _function_wrapper(*args, **kwargs):
+            useTimeout = timeoutFunction(*args, **kwargs)
+
+            return func_timeout(useTimeout, func, args=args, kwargs=kwargs)
+
+        return wraps(func)(_function_wrapper)
+    return _function_decorator
+
+
+# vim: set ts=4 sw=4 expandtab :

{funboost-44.7.dist-info → funboost-44.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: funboost
-Version: 44.7
+Version: 44.9
 Summary: pip install funboost，python全功能分布式函数调度框架,。支持python所有类型的并发模式和一切知名消息队列中间件，支持如 celery dramatiq等框架整体作为funboost中间件，python函数加速器，框架包罗万象，用户能想到的控制功能全都有。一统编程思维，兼容50% python业务场景，适用范围广。只需要一行代码即可分布式执行python一切函数，99%用过funboost的pythoner 感受是　简易 方便 强劲 强大，相见恨晚 
 Home-page: https://github.com/ydf0509/funboost
 Author: bfzs

{funboost-44.7.dist-info → funboost-44.9.dist-info}/RECORD

@@ -1,9 +1,9 @@
-funboost/__init__.py,sha256=VvKY_geEn7zzd9pPmdIQtFCoFxFSf-fycagti5lnwsY,3957
+funboost/__init__.py,sha256=Ki3on2Rd5a9xM8t0KMXYipvSBeJcqjW3aHco_92bGtA,3957
 funboost/__init__old.py,sha256=07A1MLsxLtuRQQOIfDyphddOwNBrGe34enoHWAnjV14,20379
 funboost/__main__.py,sha256=-6Nogi666Y0LN8fVm3JmHGTOk8xEGWvotW_GDbSaZME,1065
-funboost/constant.py,sha256=-QFaxH3tX9AlK9Fmq2hNjxuBWXpmnpCpuZayj7c-xW8,7768
+funboost/constant.py,sha256=PqD6qx0IahvvpVXCiaTOm14GeH5rCRWVdHC45gYQsXc,8088
 funboost/funboost_config_deafult.py,sha256=K-kCFGEjD107wHWFspNrIWsPNSVteP2Xww1yRbXd-Wk,6651
-funboost/set_frame_config.py,sha256=ueaAjIOSGXrOj-Wyz5rov2tQFnkQHBePJrJ8k0tO3jM,14344
+funboost/set_frame_config.py,sha256=YOTvzW1pIXg4HAhrOT0usPOHmx95rfx95B65CMrNNMo,14436
 funboost/assist/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 funboost/assist/celery_helper.py,sha256=EOxsl-y65JPwHrmL0LTGAj1nKLbS0qyRbuXcJ0xo9wc,5721
 funboost/assist/dramatiq_helper.py,sha256=9mUyfBMAJXzwvB8LwOmapn3rY30a6UXt3tNOfL6OXoM,2106
@@ -33,7 +33,7 @@ funboost/concurrent_pool/backup/async_pool_executor0223.py,sha256=RVUZiylUvpTm6U
 funboost/concurrent_pool/backup/async_pool_executor_back.py,sha256=KL6zEQaa1KkZOlAO85mCC1gwLm-YC5Ghn21IUom0UKM,9598
 funboost/concurrent_pool/backup/async_pool_executor_janus.py,sha256=OHMWJ9l3EYTpPpcrPrGGKd4K0tmQ2PN8HiX0Dta0EOo,5728
 funboost/consumers/__init__.py,sha256=ZXY_6Kut1VYNQiF5aWEgIWobsW1ht9YUP0TdRZRWFqI,126
-funboost/consumers/base_consumer.py,sha256=ZauakWwhNTpZMPNzTwL9US2YqQWxBVBZJ7pnayaUW3E,76980
+funboost/consumers/base_consumer.py,sha256=WrZuKfp77m1NHo5LbxlZUgEfQ3foB0OEUPJWk-V4zaE,79520
 funboost/consumers/celery_consumer.py,sha256=9gtz7nlZkmv3ErmaseT0_Q__ltSPx-fOcwi-TMPoaLA,9220
 funboost/consumers/confirm_mixin.py,sha256=eY6fNwx51Hn4bQSYRjyTRwOqfCGsikVnd2Ga_Ep31N4,6062
 funboost/consumers/dramatiq_consumer.py,sha256=ozmeAfeF0U-YNYHK4suQB0N264h5AZdfMH0O45Mh-8A,2229
@@ -83,19 +83,19 @@ funboost/contrib/redis_consume_latest_msg_broker.py,sha256=ESortBZ2qu_4PBCa3e3Fe
 funboost/contrib/save_result_status_to_sqldb.py,sha256=AxvD7nHs4sjr9U0kwEZzyPKrsGdU_JzEgzzhh_V1_4w,4071
 funboost/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 funboost/core/active_cousumer_info_getter.py,sha256=09fEc-BTEIRfDDfHmOvKnMjLjtOyp4edLsUlAXUR_Qs,4966
-funboost/core/booster.py,sha256=dEr3uFzGg3Tik3fvCm20WREIPpWO825Crj-DzBtby1w,17224
-funboost/core/current_task.py,sha256=MF8WfMtdmJaO779OoUNmRswbZcToyRx8TbJwxqemfo8,5255
+funboost/core/booster.py,sha256=toTSkXhKE7dqukZAbtOEr6Jz4nPz4LlmValCMreujzo,18191
+funboost/core/current_task.py,sha256=DTfiVbrrz8p8qX0VjErEaXXaScFMspKRrdmwIdbLZOM,5705
 funboost/core/exceptions.py,sha256=pLF7BkRJAfDiWp2_xGZqencmwdPiSQI1NENbImExknY,1311
 funboost/core/fabric_deploy_helper.py,sha256=foieeqlNySuU9axJzNF6TavPjIUSYBx9UO3syVKUiyY,9999
 funboost/core/funboost_config_getter.py,sha256=TDccp5pQamkoJXkwyPwGsQGDJY8ej8ZT8L8RESSAD2w,382
 funboost/core/funboost_current_task_context_thread.py,sha256=RRhqmRl943jBccgTrsfra4lS20X0zB2TtLAUaZn_A18,441
 funboost/core/funboost_time.py,sha256=IbB4dFCpg3oGUe90ssAJ_x0eDPtAVfvsUr4esdoKaOk,1777
-funboost/core/func_params_model.py,sha256=T-P-prhqCIPf0r5ZKPOTF7nawest4S1w0SRE0iynpvc,19849
+funboost/core/func_params_model.py,sha256=QjBLS6AK6l5lNrb0swGwG69nEwKoMpCds6J99jCHEBY,21069
 funboost/core/function_result_status_config.py,sha256=PyjqAQOiwsLt28sRtH-eYRjiI3edPFO4Nde0ILFRReE,1764
 funboost/core/function_result_status_saver.py,sha256=UdokGSwU630t70AZnT9Ecj7GpYXORBDivlc9kadoI2E,9172
 funboost/core/helper_funs.py,sha256=1MZjedV6TGdaAjmj9q-ykgoTI_BtG9ZQm58PLOMVdDM,2362
 funboost/core/kill_remote_task.py,sha256=MZ5vWLGt6SxyN76h5Lf_id9tyVUzjR-qXNyJwXaGlZY,8129
-funboost/core/lazy_impoter.py,sha256=wH7u8nm6rLGtWmF643d5ga4CrJEmAhaSsDEBEeuiD4Q,4825
+funboost/core/lazy_impoter.py,sha256=5yToRBbTB338heR787ap5i-UAGN0FanUCkYfK9Nsgnk,4957
 funboost/core/loggers.py,sha256=uy5mFLIUvKaVdJZLi6THyxqeuOmp9XEOKrH1Yci0zUM,2354
 funboost/core/msg_result_getter.py,sha256=oZDuLDR5XQNzzvgDTsA7wroICToPwrkU9-OAaXXUQSk,8031
 funboost/core/muliti_process_enhance.py,sha256=tI3178inc5sqPh-jQc0XaTuUD1diIZyHuukBRk1Gp6Y,3595
@@ -125,7 +125,7 @@ funboost/function_result_web/static/js/jquery-1.11.0.min.js,sha256=ryQZ3RXgnqkTz
 funboost/function_result_web/templates/index.html,sha256=YM0582Q4t2da-xBf3Ga0McIfcsT9H98rjZck-irMkGo,20387
 funboost/function_result_web/templates/login.html,sha256=q37dj7O0LeyiV38Zd5P1Qn_qmhjdFomuYTRY1Yk48Bo,2007
 funboost/publishers/__init__.py,sha256=xqBHlvsJQVPfbdvP84G0LHmVB7-pFBS7vDnX1Uo9pVY,131
-funboost/publishers/base_publisher.py,sha256=Y0pzWgvJi1v3UrSrOewPsWpxnKgfUseV6pP28dXL5G0,15081
+funboost/publishers/base_publisher.py,sha256=rwqfCQatpGzxluEVjsXwqxbuWnjUC_erIuEg9mKR1-o,16598
 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
@@ -173,7 +173,7 @@ funboost/utils/__init__.py,sha256=rAyXE7lgCo_3VdMvGrIJiqsTHv2nZPTJDTj1f6s_KgE,58
 funboost/utils/apscheduler_monkey.py,sha256=CcUISbqX6nMWSxr_QjZ26IvvhUk_ojYZWRaKenpsKfE,3124
 funboost/utils/block_exit.py,sha256=BnfxNYo3lnmhk686RAEoc4u3D4RU_iEMMMgu5L8gIuI,96
 funboost/utils/bulk_operation.py,sha256=B4FBxlz5f4oqlKDWqer7axn4gnDSfsYoMW2zSUCnGcQ,10101
-funboost/utils/class_utils.py,sha256=EZ98CzeoaN2H8iOABTOPefMVfdrii9XDwATqZ0_CkUQ,1153
+funboost/utils/class_utils.py,sha256=yDsGF4-SaO7k4gtkpYLlACSeejS5FfdIHn087BE_4Cw,3579
 funboost/utils/ctrl_c_end.py,sha256=FgT9An-qsUA5gW-V-UKWqOh5shC7C_uvTFn0fS7i8GI,439
 funboost/utils/custom_pysnooper.py,sha256=7yXLKEMY_JjPRRt0Y0N-wV2CFhILlYNh40Y6uRBUaj8,5923
 funboost/utils/decorators.py,sha256=lyi9TCBg__7xkoV17AZhRItTn95vU2XMtOxfXJVV5B4,26601
@@ -224,15 +224,16 @@ funboost/utils/dependency_packages_in_pythonpath/aioredis/__pycache__/connection
 funboost/utils/dependency_packages_in_pythonpath/aioredis/__pycache__/exceptions.cpython-39.pyc,sha256=EL9HO-DGiUifKhsYJb1IhBXTkiPKYh_6tAOPgCrlzFc,3135
 funboost/utils/dependency_packages_in_pythonpath/aioredis/__pycache__/lock.cpython-39.pyc,sha256=8toq_bQ96ifLGuoKqZAW4fG06lTBt31y7m3ZYB-ayXU,10198
 funboost/utils/dependency_packages_in_pythonpath/aioredis/__pycache__/utils.cpython-39.pyc,sha256=1Qi5z-nd1F1LsWV6KVi2upaJ8NvfIhtYT5GVpjtgGlA,2017
-funboost/utils/dependency_packages_in_pythonpath/func_timeout/StoppableThread.py,sha256=v15aAZDBtS42hDn4x5tjKBs6MGUKICztv0rUJ7aPcAQ,5379
+funboost/utils/dependency_packages_in_pythonpath/func_timeout/StoppableThread.py,sha256=Hz8SKOO1Jg4sQWnsVMQ9N1agTWyBdml_BpGnUN9wfwY,5517
 funboost/utils/dependency_packages_in_pythonpath/func_timeout/__init__.py,sha256=P3gPbNKNWi0P9ASJcFBnxsxiyII-3neM-FsVjwT_IeU,603
-funboost/utils/dependency_packages_in_pythonpath/func_timeout/dafunc.py,sha256=-epJVpSkE4wxlfLx-n_0cRbYHuBcMonghmsL-idqbcQ,9913
+funboost/utils/dependency_packages_in_pythonpath/func_timeout/dafunc.py,sha256=Yy98BzsmgWi07ja5zM4ElLwb1h8NXahxtRG5YC4_R7Q,9828
+funboost/utils/dependency_packages_in_pythonpath/func_timeout/dafunc2222.py,sha256=s7hkiBrLWHSWy78KiCRqHxynT6QdBmxnhm2N7US6elY,9872
 funboost/utils/dependency_packages_in_pythonpath/func_timeout/exceptions.py,sha256=ilz6xOeq-H0qspAraXfScQTBEQ8TME3i9FItDscm3H0,4072
 funboost/utils/dependency_packages_in_pythonpath/func_timeout/py2_raise.py,sha256=HS-jk-HqLm4jHK82bw8P_FmrrifAG8DAol_gEmIW6nE,176
 funboost/utils/dependency_packages_in_pythonpath/func_timeout/py3_raise.py,sha256=lrJ3yWuym8-rcQ_s___E5w7bzJ1dFGpXtmWo3RPpJoE,287
-funboost/utils/dependency_packages_in_pythonpath/func_timeout/__pycache__/StoppableThread.cpython-39.pyc,sha256=kvj4jhPh6HHMUw3aWdBImNa5T-vQyuu85ozqEjG4lSg,5083
+funboost/utils/dependency_packages_in_pythonpath/func_timeout/__pycache__/StoppableThread.cpython-39.pyc,sha256=k_DjgnG9gFv3D4k_pdOjiw5MFVvEX-405opzLxUCan8,5141
 funboost/utils/dependency_packages_in_pythonpath/func_timeout/__pycache__/__init__.cpython-39.pyc,sha256=m4vNDlsjMFuAOjmudVIWvyp_7Td0NlpjA_nRGZvPbQk,767
-funboost/utils/dependency_packages_in_pythonpath/func_timeout/__pycache__/dafunc.cpython-39.pyc,sha256=OVbQyeN-uKwLRaqqVlpjAG0hTHAvomyq1CcHl79vynA,8185
+funboost/utils/dependency_packages_in_pythonpath/func_timeout/__pycache__/dafunc.cpython-39.pyc,sha256=gIsUIfM8jptQSf535IcCKL-tgRpdnIfCEvdrRpSNx2M,8086
 funboost/utils/dependency_packages_in_pythonpath/func_timeout/__pycache__/exceptions.cpython-39.pyc,sha256=pzFmbSiuiYivY1RIUFOMXc12EJSIZc0gKO96KitxPoE,3732
 funboost/utils/dependency_packages_in_pythonpath/func_timeout/__pycache__/py3_raise.cpython-39.pyc,sha256=zE4fCYsao9dA1bC8aBT0fzYT8yTYuTQqMk9LFPClCyc,311
 funboost/utils/pysnooper_ydf/__init__.py,sha256=ctbQdJpLVZ5g_PPstj7Xaqcl0sMIgvUGwZXtcogYyHA,909
@@ -242,9 +243,9 @@ funboost/utils/pysnooper_ydf/utils.py,sha256=evSmGi_Oul7vSP47AJ0DLjFwoCYCfunJZ1m
 funboost/utils/pysnooper_ydf/variables.py,sha256=QejRDESBA06KG9OH4sBT4J1M55eaU29EIHg8K_igaXo,3693
 funboost/utils/times/__init__.py,sha256=z-KQTxXapfu2ScJxISGe7QGffASuyJYL6JGsLXxD6O0,2332
 funboost/utils/times/version.py,sha256=JiZLGTB-HYyBOV4xS0rnx2K2OqVMTebUj30sZRbrleE,16
-funboost-44.7.dist-info/LICENSE,sha256=9EPP2ktG_lAPB8PjmWV-c9BiaJHc_FP6pPLcUrUwx0E,11562
-funboost-44.7.dist-info/METADATA,sha256=sWXcozUL0NVSYgPv7MgdgduVHExNH9_VPravfYjjPlI,31691
-funboost-44.7.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-funboost-44.7.dist-info/entry_points.txt,sha256=yMSSAGRzRAAhGyNNQHw24MooKlDZsaJ499_D6fPl58A,96
-funboost-44.7.dist-info/top_level.txt,sha256=K8WuKnS6MRcEWxP1NvbmCeujJq6TEfbsB150YROlRw0,9
-funboost-44.7.dist-info/RECORD,,
+funboost-44.9.dist-info/LICENSE,sha256=9EPP2ktG_lAPB8PjmWV-c9BiaJHc_FP6pPLcUrUwx0E,11562
+funboost-44.9.dist-info/METADATA,sha256=IQaRHQKT466IEEu0J0quGBO6Qm8qZqIpDQXilHEtZFk,31691
+funboost-44.9.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+funboost-44.9.dist-info/entry_points.txt,sha256=yMSSAGRzRAAhGyNNQHw24MooKlDZsaJ499_D6fPl58A,96
+funboost-44.9.dist-info/top_level.txt,sha256=K8WuKnS6MRcEWxP1NvbmCeujJq6TEfbsB150YROlRw0,9
+funboost-44.9.dist-info/RECORD,,