funboost 44.8__tar.gz → 44.9__tar.gz

{funboost-44.8/funboost.egg-info → funboost-44.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: funboost
-Version: 44.8
+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
@@ -492,4 +492,3 @@ funboost通过支持celery作为broker_kind,使celer框架变成了funboost的
 ![](https://visitor-badge.glitch.me/badge?page_id=distributed_framework)
 
 <div> </div>
-

{funboost-44.8 → funboost-44.9}/funboost/__init__.py

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

{funboost-44.8 → funboost-44.9}/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-44.8 → funboost-44.9}/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-44.8 → funboost-44.9}/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-44.9/funboost/core/current_task.py

@@ -0,0 +1,193 @@
+import abc
+import contextvars
+from dataclasses import dataclass
+import logging
+import threading
+import asyncio
+
+from funboost.core.function_result_status_saver import FunctionResultStatus
+
+""" 用法例子 
+    '''
+    fct = funboost_current_task()
+    print(fct.function_result_status.get_status_dict())
+    print(fct.function_result_status.task_id)
+    print(fct.function_result_status.run_times)
+    print(fct.full_msg)
+    '''
+import random
+import time
+
+from funboost import boost, FunctionResultStatusPersistanceConfig,BoosterParams
+from funboost.core.current_task import funboost_current_task
+
+@boost(BoosterParams(queue_name='queue_test_f01', qps=2,concurrent_num=5,
+       function_result_status_persistance_conf=FunctionResultStatusPersistanceConfig(
+           is_save_status=True, is_save_result=True, expire_seconds=7 * 24 * 3600)))
+def f(a, b):
+    fct = funboost_current_task()
+    print(fct.function_result_status.get_status_dict())
+    print(fct.function_result_status.task_id)
+    print(fct.function_result_status.run_times)
+    print(fct.full_msg)
+
+    time.sleep(20)
+    if random.random() > 0.5:
+        raise Exception(f'{a} {b} 模拟出错啦')
+    print(a+b)
+
+    return a + b
+
+
+if __name__ == '__main__':
+    # f(5, 6)  # 可以直接调用
+
+    for i in range(0, 200):
+        f.push(i, b=i * 2)
+
+    f.consume()
+
+    """
+
+
+@dataclass
+class FctContext:
+    """
+    fct 是 funboost current task 的简写
+    """
+
+    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.get_fct_context().function_params
+
+    @property
+    def full_msg(self) -> dict:
+        return self.get_fct_context().full_msg
+
+    @property
+    def function_result_status(self) -> FunctionResultStatus:
+        return self.get_fct_context().function_result_status
+
+    @property
+    def task_id(self) -> FunctionResultStatus:
+        return self.function_result_status.task_id
+
+    @property
+    def logger(self) -> logging.Logger:
+        return self.get_fct_context().logger
+
+    def __str__(self):
+        return f'<{self.__class__.__name__} [{self.function_result_status.get_status_dict()}]>'
+
+
+class __ThreadCurrentTask(_BaseCurrentTask):
+    """
+    用于在用户自己函数内部去获取 消息的完整体,当前重试次数等.
+    """
+
+    _fct_local_data = threading.local()
+
+    def set_fct_context(self, fct_context: FctContext):
+        self._fct_local_data.fct_context = fct_context
+
+    def get_fct_context(self) -> FctContext:
+        return self._fct_local_data.fct_context
+
+
+class __AsyncioCurrentTask(_BaseCurrentTask):
+    _fct_context = contextvars.ContextVar('fct_context')
+
+    def set_fct_context(self, fct_context: FctContext):
+        self._fct_context.set(fct_context)
+
+    def get_fct_context(self) -> FctContext:
+        return self._fct_context.get()
+
+
+thread_current_task = __ThreadCurrentTask()
+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 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
+    else:
+        return thread_current_task
+
+
+def get_current_taskid():
+    fct = funboost_current_task()
+    # return fct.function_result_status.task_id
+    try:
+        return fct.task_id  # 不在funboost的消费函数里面就获取不到上下文了
+    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(2):
+        funboost_current_task()
+        print(get_current_taskid())
+    print()

{funboost-44.8 → funboost-44.9}/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-44.8 → funboost-44.9}/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-44.8 → funboost-44.9}/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-44.9/funboost/utils/class_utils.py

@@ -0,0 +1,101 @@
+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