funboost 46.0__tar.gz → 46.1__tar.gz

{funboost-46.0/funboost.egg-info → funboost-46.1}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: funboost
-Version: 46.0
-Summary: pip install funboost，python全功能分布式函数调度框架,。支持python所有类型的并发模式和一切知名消息队列中间件，支持如 celery dramatiq等框架整体作为funboost中间件，python函数加速器，框架包罗万象，用户能想到的控制功能全都有。一统编程思维，兼容50% python业务场景，适用范围广。只需要一行代码即可分布式执行python一切函数，99%用过funboost的pythoner 感受是　简易 方便 强劲 强大，相见恨晚 
+Version: 46.1
+Summary: pip install funboost，python全功能分布式函数调度框架,funboost的功能是全面性重量级，用户能想得到的功能99%全都有;funboost的使用方式是轻量级，只有@boost一行代码需要写。支持python所有类型的并发模式和一切知名消息队列中间件，支持如 celery dramatiq等框架整体作为funboost中间件，python函数加速器，框架包罗万象，用户能想到的控制功能全都有。一统编程思维，兼容50% python业务场景，适用范围广。只需要一行代码即可分布式执行python一切函数，99%用过funboost的pythoner 感受是　简易 方便 强劲 强大，相见恨晚 
 Home-page: https://github.com/ydf0509/funboost
 Author: bfzs
 Author-email: ydf0509@sohu.com
@@ -49,6 +49,8 @@ License-File: LICENSE
 <pre style="color: greenyellow;background-color: #0c1119; font-size: medium;">
 pip install funboost ,python全功能分布式函数调度框架。  demo用法例子见文档1.3
 
+funboost的功能是全面性重量级，用户能想得到的功能99%全都有;funboost的使用方式是轻量级，只有@boost一行代码需要写。
+
 只需要一行@boost代码即可分布式执行python一切任意函数，99%用过funboost的pythoner 感受是 方便 快速 强大。
 支持python所有类型的并发模式,消息队列方面支持全球一切知名消息队列中间件和模拟的实现消息队列，
 同时funboost支持celery整个框架作为核心来发布和消费消息，使用funboost的极简api方式来自动化配置和利用celery调度,
@@ -101,6 +103,7 @@ funboost的旧框架名字是function_scheduling_distributed_framework , 关系
 [查看分布式函数调度框架文档 https://funboost.readthedocs.io/zh-cn/latest/index.html](https://funboost.readthedocs.io/zh-cn/latest/index.html)
 
 
+ 
 [funboost依赖的nb_log日志文档 https://nb-log-doc.readthedocs.io/zh_CN/latest/articles/c9.html#id2](https://nb-log-doc.readthedocs.io/zh_CN/latest/articles/c9.html#id2)
 
 ```

{funboost-46.0 → funboost-46.1}/README.md

@@ -17,6 +17,8 @@
 <pre style="color: greenyellow;background-color: #0c1119; font-size: medium;">
 pip install funboost ,python全功能分布式函数调度框架。  demo用法例子见文档1.3
 
+funboost的功能是全面性重量级，用户能想得到的功能99%全都有;funboost的使用方式是轻量级，只有@boost一行代码需要写。
+
 只需要一行@boost代码即可分布式执行python一切任意函数，99%用过funboost的pythoner 感受是 方便 快速 强大。
 支持python所有类型的并发模式,消息队列方面支持全球一切知名消息队列中间件和模拟的实现消息队列，
 同时funboost支持celery整个框架作为核心来发布和消费消息，使用funboost的极简api方式来自动化配置和利用celery调度,
@@ -69,6 +71,7 @@ funboost的旧框架名字是function_scheduling_distributed_framework , 关系
 [查看分布式函数调度框架文档 https://funboost.readthedocs.io/zh-cn/latest/index.html](https://funboost.readthedocs.io/zh-cn/latest/index.html)
 
 
+ 
 [funboost依赖的nb_log日志文档 https://nb-log-doc.readthedocs.io/zh_CN/latest/articles/c9.html#id2](https://nb-log-doc.readthedocs.io/zh_CN/latest/articles/c9.html#id2)
 
 ```

{funboost-46.0 → funboost-46.1}/funboost/__init__.py

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

{funboost-46.0 → funboost-46.1}/funboost/assist/celery_helper.py

@@ -1,3 +1,5 @@
+import copy
+
 import json
 import logging
 import os
@@ -79,10 +81,18 @@ class CeleryHelper:
         cls.to_be_start_work_celery_queue_name_set.add(queue_name)
 
     @classmethod
-    def realy_start_celery_worker(cls, worker_name=None, loglevel='INFO'):
-        if len(cls.to_be_start_work_celery_queue_name_set) == 0:
+    def realy_start_celery_worker(cls, worker_name=None, loglevel='INFO',worker_concurrency=200,start_consume_queue_name_list:list=None,is_start_consume_all_queues:bool=False):
+
+        if is_start_consume_all_queues is False:
+            to_be_start_work_celery_queue_name_set_new = copy.copy(cls.to_be_start_work_celery_queue_name_set)
+            to_be_start_work_celery_queue_name_set_new.update(set(start_consume_queue_name_list))
+        else:
+            from funboost import BoostersManager
+            # print(BoostersManager.get_all_queues())
+            to_be_start_work_celery_queue_name_set_new = set(BoostersManager.get_all_queues())
+        queue_names_str = ','.join(list(to_be_start_work_celery_queue_name_set_new))
+        if not to_be_start_work_celery_queue_name_set_new:
             raise Exception('celery worker 没有需要运行的queue')
-        queue_names_str = ','.join(list(cls.to_be_start_work_celery_queue_name_set))
         # '--concurrency=200',
         # '--autoscale=5,500' threads 并发模式不支持自动扩大缩小并发数量,
         worker_name = worker_name or f'pid_{os.getpid()}'
@@ -97,7 +107,10 @@ class CeleryHelper:
              # 'worker_redirect_stdouts': False,
              'worker_concurrency': 200
          }
+         或
+         CeleryHelper.update_celery_app_conf({ 'worker_concurrency': 500})
         '''
+        cls.update_celery_app_conf({'worker_concurrency':worker_concurrency})
         argv = ['worker', f'--pool={pool_name}',
                 '-n', f'worker_funboost_{worker_name}@%h', f'--loglevel={loglevel}',
                 f'--queues={queue_names_str}',  # 并发数量是 在app配置中已经制定了。自己用 update_celery_app_conf 方法更新就好了。

{funboost-46.0 → funboost-46.1}/funboost/consumers/base_consumer.py

@@ -120,6 +120,7 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         """
         # ConsumersManager.join_all_consumer_shedual_task_thread()
         if GlobalVars.has_start_a_consumer_flag:
+            # self.keep_circulating(10,block=True,)(time.sleep)()
             while 1:
                 time.sleep(10)
 
@@ -287,12 +288,13 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         pass
 
     def keep_circulating(self, time_sleep=0.001, exit_if_function_run_sucsess=False, is_display_detail_exception=True,
-                         block=True):
+                         block=True, daemon=False):
         """间隔一段时间，一直循环运行某个方法的装饰器
         :param time_sleep :循环的间隔时间
         :param is_display_detail_exception
         :param exit_if_function_run_sucsess :如果成功了就退出循环
         :param block:是否阻塞在当前主线程运行。
+        :param daemon:是否守护线程
         """
 
         def _keep_circulating(func):
@@ -316,11 +318,12 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
                             self.logger.error(msg=log_msg, exc_info=True)
                         finally:
                             time.sleep(time_sleep)
+                            # print(func,time_sleep)
 
                 if block:
                     return ___keep_circulating()
                 else:
-                    threading.Thread(target=___keep_circulating, ).start()
+                    threading.Thread(target=___keep_circulating, daemon=daemon).start()
 
             return __keep_circulating
 
@@ -351,14 +354,14 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
             self._distributed_consumer_statistics.run()
             self.logger.warning(f'启动了分布式环境 使用 redis 的键 hearbeat:{self._queue_name} 统计活跃消费者 ，当前消费者唯一标识为 {self.consumer_identification}')
 
-        self.keep_circulating(60, block=False)(self.check_heartbeat_and_message_count)()  # 间隔时间最好比self._unit_time_for_count小整数倍，不然日志不准。
+        self.keep_circulating(60, block=False, daemon=False)(self.check_heartbeat_and_message_count)()  # 间隔时间最好比self._unit_time_for_count小整数倍，不然日志不准。
         if self.consumer_params.is_support_remote_kill_task:
             kill_remote_task.RemoteTaskKiller(self.queue_name, None).start_cycle_kill_task()
             self.consumer_params.is_show_message_get_from_broker = True  # 方便用户看到从消息队列取出来的消息的task_id,然后使用task_id杀死运行中的消息。
         if self.consumer_params.do_task_filtering:
             self._redis_filter.delete_expire_filter_task_cycle()  # 这个默认是RedisFilter类，是个pass不运行。所以用别的消息中间件模式，不需要安装和配置redis。
         if self.consumer_params.schedule_tasks_on_main_thread:
-            self.keep_circulating(1)(self._shedual_task)()
+            self.keep_circulating(1, daemon=False)(self._shedual_task)()
         else:
             self._concurrent_mode_dispatcher.schedulal_task_with_no_block()
 
@@ -1108,7 +1111,7 @@ class ConcurrentModeDispatcher(FunboostFileLoggerMixin):
     #             ConsumersManager.schedulal_thread_to_be_join.append(g)
 
     def schedulal_task_with_no_block(self):
-        self.consumer.keep_circulating(1, block=False)(self.consumer._shedual_task)()
+        self.consumer.keep_circulating(1, block=False, daemon=False)(self.consumer._shedual_task)()
 
 
 def wait_for_possible_has_finish_all_tasks_by_conusmer_list(consumer_list: typing.List[AbstractConsumer], minutes: int = 3):
@@ -1139,6 +1142,13 @@ class DistributedConsumerStatistics(RedisMixin, FunboostFileLoggerMixin):
 
     3、从redis中获取停止和暂停状态，以便支持在别的地方发送命令停止或者暂停消费。
     """
+    SHOW_CONSUMER_NUM_INTERVAL = 600
+    HEARBEAT_EXPIRE_SECOND = 25
+    SEND_HEARTBEAT_INTERVAL = 10
+
+    if HEARBEAT_EXPIRE_SECOND < SEND_HEARTBEAT_INTERVAL * 2:
+        raise ValueError(f'HEARBEAT_EXPIRE_SECOND:{HEARBEAT_EXPIRE_SECOND} , SEND_HEARTBEAT_INTERVAL:{SEND_HEARTBEAT_INTERVAL} ')
+
 
     def __init__(self, consumer: AbstractConsumer):
         # self._consumer_identification = consumer_identification
@@ -1157,8 +1167,7 @@ class DistributedConsumerStatistics(RedisMixin, FunboostFileLoggerMixin):
 
     def run(self):
         self.send_heartbeat()
-        self._consumer.keep_circulating(10, block=False)(self.send_heartbeat)()
-        # decorators.keep_circulating(5, block=False)(self._show_active_consumer_num)()  # 主要是为快速频繁统计分布式消费者个数，快速调整分布式qps控频率。
+        self._consumer.keep_circulating(self.SEND_HEARTBEAT_INTERVAL, block=False, daemon=False)(self.send_heartbeat)()
 
     def _send_heartbeat_with_dict_value(self, redis_key, ):
         # 发送当前消费者进程心跳的，值是字典，按一个机器或者一个队列运行了哪些进程。
@@ -1167,7 +1176,7 @@ class DistributedConsumerStatistics(RedisMixin, FunboostFileLoggerMixin):
         with self.redis_db_frame.pipeline() as p:
             for result in results:
                 result_dict = Serialization.to_dict(result)
-                if self.timestamp() - result_dict['hearbeat_timestamp'] > 15 \
+                if self.timestamp() - result_dict['hearbeat_timestamp'] > self.HEARBEAT_EXPIRE_SECOND \
                         or self._consumer_identification_map['consumer_uuid'] == result_dict['consumer_uuid']:
                     # 因为这个是10秒钟运行一次，15秒还没更新，那肯定是掉线了。如果消费者本身是自己也先删除。
                     p.srem(redis_key, result)
@@ -1179,10 +1188,11 @@ class DistributedConsumerStatistics(RedisMixin, FunboostFileLoggerMixin):
 
     def send_heartbeat(self):
         # 根据队列名心跳的，值是字符串，方便值作为其他redis的键名
+
         results = self.redis_db_frame.smembers(self._redis_key_name)
         with self.redis_db_frame.pipeline() as p:
             for result in results:
-                if self.timestamp() - float(result.split('&&')[-1]) > 15 or \
+                if self.timestamp() - float(result.split('&&')[-1]) > self.HEARBEAT_EXPIRE_SECOND or \
                         self._consumer_identification == result.split('&&')[0]:  # 因为这个是10秒钟运行一次，15秒还没更新，那肯定是掉线了。如果消费者本身是自己也先删除。
                     p.srem(self._redis_key_name, result)
             p.sadd(self._redis_key_name, f'{self._consumer_identification}&&{self.timestamp()}')
@@ -1193,9 +1203,10 @@ class DistributedConsumerStatistics(RedisMixin, FunboostFileLoggerMixin):
         self._show_active_consumer_num()
         self._get_stop_and_pause_flag_from_redis()
 
+
     def _show_active_consumer_num(self):
         self.active_consumer_num = self.redis_db_frame.scard(self._redis_key_name) or 1
-        if time.time() - self._last_show_consumer_num_timestamp > 600:
+        if time.time() - self._last_show_consumer_num_timestamp > self.SHOW_CONSUMER_NUM_INTERVAL:
             self.logger.info(f'分布式所有环境中使用 {self._queue_name} 队列的，一共有 {self.active_consumer_num} 个消费者')
             self._last_show_consumer_num_timestamp = time.time()
 

{funboost-46.0 → funboost-46.1}/funboost/consumers/celery_consumer.py

@@ -180,7 +180,7 @@ class CeleryConsumer(AbstractConsumer):
                     log_msg = f'fun: {self.consuming_function}  args: {args} , kwargs: {kwargs} 消息达到最大重试次数{this.request.retries}次仍然出错,  {exc} \n'
                     self.logger.critical(log_msg, exc_info=self.consumer_params.is_print_detail_exception)
                 # 发生异常，尝试重试任务,countdown 是多少秒后重试
-                raise this.retry(exc=exc, countdown=5)
+                raise this.retry(exc=exc, countdown=self.consumer_params.retry_interval)
 
         celery_app.conf.task_routes.update({self.queue_name: {"queue": self.queue_name}})  # 自动配置celery每个函数使用不同的队列名。
         self.celery_task = f

{funboost-46.0 → funboost-46.1}/funboost/consumers/confirm_mixin.py

@@ -27,7 +27,7 @@ class ConsumerConfirmMixinWithTheHelpOfRedis(RedisMixin):
         self._unack_zset_name = f'{self._queue_name}__unack'
 
     def start_consuming_message(self):
-        self._is_send_consumer_hearbeat_to_redis = True
+        self.consumer_params.is_send_consumer_hearbeat_to_redis = True
         super().start_consuming_message()
         self.keep_circulating(60, block=False)(self._requeue_tasks_which_unconfirmed)()
 
@@ -62,14 +62,14 @@ class ConsumerConfirmMixinWithTheHelpOfRedisByHearbeat(ConsumerConfirmMixinWithT
     # noinspection PyAttributeOutsideInit
     def custom_init(self):
         self._unack_zset_name = f'{self._queue_name}__unack_id_{self.consumer_identification}'
-        self._is_send_consumer_hearbeat_to_redis = True
+        self.consumer_params.is_send_consumer_hearbeat_to_redis = True
         self._last_show_unacked_msg_num_log = 0
 
     def _requeue_tasks_which_unconfirmed(self):
         lock_key = f'fsdf_lock__requeue_tasks_which_unconfirmed:{self._queue_name}'
         with decorators.RedisDistributedLockContextManager(self.redis_db_frame, lock_key, ).set_log_level(30) as lock:
             if lock.has_aquire_lock:
-                self._distributed_consumer_statistics.send_heartbeat()
+                # self._distributed_consumer_statistics.send_heartbeat() # 已经周期运行了。
                 current_queue_hearbeat_ids = self._distributed_consumer_statistics.get_queue_heartbeat_ids(without_time=True)
                 current_queue_unacked_msg_queues = self.redis_db_frame.scan(0, f'{self._queue_name}__unack_id_*', count=self.SCAN_COUNT) # 不要在funboost的队列所在db放弃他缓存keys，要保持db的keys少于1000，否则要多次scan。
                 # print(current_queue_unacked_msg_queues)

{funboost-46.0 → funboost-46.1}/funboost/consumers/redis_brpoplpush_consumer.py

@@ -17,7 +17,7 @@ class RedisBrpopLpushConsumer(AbstractConsumer, RedisMixin):
 
 
     def start_consuming_message(self):
-        self._is_send_consumer_hearbeat_to_redis = True
+        self.consumer_params.is_send_consumer_hearbeat_to_redis = True
         super().start_consuming_message()
         self.keep_circulating(60, block=False)(self._requeue_tasks_which_unconfirmed)()
 

{funboost-46.0 → funboost-46.1}/funboost/consumers/redis_consumer_ack_using_timeout.py

@@ -29,7 +29,7 @@ class RedisConsumerAckUsingTimeout(AbstractConsumer, RedisMixin):
         self._last_show_unack_ts = time.time()
 
     def start_consuming_message(self):
-        self._is_send_consumer_hearbeat_to_redis = True
+        self.consumer_params.is_send_consumer_hearbeat_to_redis = True
         super().start_consuming_message()
         self.keep_circulating(10, block=False)(self._requeue_tasks_which_unconfirmed)()
 

{funboost-46.0 → funboost-46.1}/funboost/consumers/redis_stream_consumer.py

@@ -28,7 +28,7 @@ class RedisStreamConsumer(AbstractConsumer, RedisMixin):
         if self.redis_db_frame.type(self._queue_name) == 'list':
             raise EnvironmentError(f'检测到已存在 {self._queue_name} 这个键，且类型是list， 必须换个队列名字或者删除这个 list 类型的键。'
                                    f'RedisStreamConsumer 使用的是 stream 数据结构')
-        self._is_send_consumer_hearbeat_to_redis = True
+        self.consumer_params.is_send_consumer_hearbeat_to_redis = True
         super().start_consuming_message()
         self.keep_circulating(60, block=False)(self._requeue_tasks_which_unconfirmed)()
 

{funboost-46.0 → funboost-46.1}/funboost/core/booster.py

@@ -315,14 +315,15 @@ class BoostersManager:
     consume = consume_queues
 
     @classmethod
-    def consume_all_queues(cls):
+    def consume_all_queues(cls,block=True):
         """
         启动所有消息队列名的消费,无需一个一个函数亲自 funxx.consume()来启动,多个函数队列在当前同一个进程内启动消费.
         这种方式节约总的内存,但无法利用多核cpu
         """
         for queue_name in cls.get_all_queues():
             cls.get_booster(queue_name).consume()
-        ctrl_c_recv()
+        if block:
+            ctrl_c_recv()
 
     consume_all = consume_all_queues
 

{funboost-46.0 → funboost-46.1}/funboost/core/funboost_config_getter.py

@@ -3,5 +3,5 @@ def _try_get_user_funboost_common_config(funboost_common_conf_field:str):
         import funboost_config  # 第一次启动funboost前还没这个文件,或者还没有初始化配置之前,就要使用使用配置.
         return getattr(funboost_config.FunboostCommonConfig,funboost_common_conf_field)
     except Exception as e:
-        print(e)
+        # print(e)
         return None

{funboost-46.0 → funboost-46.1}/funboost/core/helper_funs.py

@@ -15,7 +15,7 @@ def get_publish_time(paramsx: dict):
 
 
 def delete_keys_and_return_new_dict(dictx: dict, keys: list = None):
-    dict_new = copy.copy(dictx)  # 主要是去掉一级键 publish_time，浅拷贝即可。新的消息已经不是这样了。
+    dict_new = copy.deepcopy(dictx)  # 主要是去掉一级键 publish_time，浅拷贝即可。新的消息已经不是这样了。
     keys = ['publish_time', 'publish_time_format', 'extra'] if keys is None else keys
     for dict_key in keys:
         try:

{funboost-46.0 → funboost-46.1/funboost.egg-info}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: funboost
-Version: 46.0
-Summary: pip install funboost，python全功能分布式函数调度框架,。支持python所有类型的并发模式和一切知名消息队列中间件，支持如 celery dramatiq等框架整体作为funboost中间件，python函数加速器，框架包罗万象，用户能想到的控制功能全都有。一统编程思维，兼容50% python业务场景，适用范围广。只需要一行代码即可分布式执行python一切函数，99%用过funboost的pythoner 感受是　简易 方便 强劲 强大，相见恨晚 
+Version: 46.1
+Summary: pip install funboost，python全功能分布式函数调度框架,funboost的功能是全面性重量级，用户能想得到的功能99%全都有;funboost的使用方式是轻量级，只有@boost一行代码需要写。支持python所有类型的并发模式和一切知名消息队列中间件，支持如 celery dramatiq等框架整体作为funboost中间件，python函数加速器，框架包罗万象，用户能想到的控制功能全都有。一统编程思维，兼容50% python业务场景，适用范围广。只需要一行代码即可分布式执行python一切函数，99%用过funboost的pythoner 感受是　简易 方便 强劲 强大，相见恨晚 
 Home-page: https://github.com/ydf0509/funboost
 Author: bfzs
 Author-email: ydf0509@sohu.com
@@ -49,6 +49,8 @@ License-File: LICENSE
 <pre style="color: greenyellow;background-color: #0c1119; font-size: medium;">
 pip install funboost ,python全功能分布式函数调度框架。  demo用法例子见文档1.3
 
+funboost的功能是全面性重量级，用户能想得到的功能99%全都有;funboost的使用方式是轻量级，只有@boost一行代码需要写。
+
 只需要一行@boost代码即可分布式执行python一切任意函数，99%用过funboost的pythoner 感受是 方便 快速 强大。
 支持python所有类型的并发模式,消息队列方面支持全球一切知名消息队列中间件和模拟的实现消息队列，
 同时funboost支持celery整个框架作为核心来发布和消费消息，使用funboost的极简api方式来自动化配置和利用celery调度,
@@ -101,6 +103,7 @@ funboost的旧框架名字是function_scheduling_distributed_framework , 关系
 [查看分布式函数调度框架文档 https://funboost.readthedocs.io/zh-cn/latest/index.html](https://funboost.readthedocs.io/zh-cn/latest/index.html)
 
 
+ 
 [funboost依赖的nb_log日志文档 https://nb-log-doc.readthedocs.io/zh_CN/latest/articles/c9.html#id2](https://nb-log-doc.readthedocs.io/zh_CN/latest/articles/c9.html#id2)
 
 ```

{funboost-46.0 → funboost-46.1}/setup.py

@@ -33,7 +33,7 @@ setup(
     name='funboost',  #
     version=__version__,
     description=(
-        'pip install funboost，python全功能分布式函数调度框架,。支持python所有类型的并发模式和一切知名消息队列中间件，支持如 celery dramatiq等框架整体作为funboost中间件，python函数加速器，框架包罗万象，用户能想到的控制功能全都有。一统编程思维，兼容50% python业务场景，适用范围广。只需要一行代码即可分布式执行python一切函数，99%用过funboost的pythoner 感受是　简易 方便 强劲 强大，相见恨晚 '
+        'pip install funboost，python全功能分布式函数调度框架,funboost的功能是全面性重量级，用户能想得到的功能99%全都有;funboost的使用方式是轻量级，只有@boost一行代码需要写。支持python所有类型的并发模式和一切知名消息队列中间件，支持如 celery dramatiq等框架整体作为funboost中间件，python函数加速器，框架包罗万象，用户能想到的控制功能全都有。一统编程思维，兼容50% python业务场景，适用范围广。只需要一行代码即可分布式执行python一切函数，99%用过funboost的pythoner 感受是　简易 方便 强劲 强大，相见恨晚 '
     ),
     # long_description=open('README.md', 'r',encoding='utf8').read(),
     keywords=["funboost", "distributed-framework", "function-scheduling", "rabbitmq", "rocketmq", "kafka", "nsq", "redis", "disk",