funboost 30.2__tar.gz → 30.4__tar.gz

{funboost-30.2/funboost.egg-info → funboost-30.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: funboost
-Version: 30.2
+Version: 30.4
 Summary: pip install funboost，python全功能分布式函数调度框架,。支持python所有类型的并发模式和一切知名消息队列中间件，支持celery框架整体作为funboost中间件，python函数加速器，框架包罗万象，一统编程思维，兼容50% python业务场景，适用范围广。只需要一行代码即可分布式执行python一切函数，99%用过funboost的pythoner 感受是 方便 快速 强大，相见恨晚 
 Home-page: https://github.com/ydf0509/funboost
 Author: bfzs
@@ -418,7 +418,7 @@ if __name__ == "__main__":
 
 [![pP2AsbQ.png](https://s1.ax1x.com/2023/09/12/pP2AsbQ.png)](https://imgse.com/i/pP2AsbQ)
 
-
+![](https://i.niupic.com/images/2019/09/20/_331.png)
 
 
 

{funboost-30.2 → funboost-30.4}/README.md

@@ -388,7 +388,7 @@ if __name__ == "__main__":
 
 [![pP2AsbQ.png](https://s1.ax1x.com/2023/09/12/pP2AsbQ.png)](https://imgse.com/i/pP2AsbQ)
 
-
+![](https://i.niupic.com/images/2019/09/20/_331.png)
 
 
 

{funboost-30.2 → funboost-30.4}/funboost/__init__.py

@@ -43,6 +43,7 @@ from funboost.constant import BrokerEnum, ConcurrentModeEnum
 from funboost.core.booster import boost, Booster
 from funboost.core.get_booster import get_booster, get_or_create_booster, get_boost_params_and_consuming_function
 from funboost.core.kill_remote_task import RemoteTaskKiller
+from funboost.funboost_config_deafult import BrokerConnConfig,FunboostCommonConfig,BoostDecoratorDefaultParams
 
 # from funboost.core.exit_signal import set_interrupt_signal_handler
 from funboost.core.helper_funs import run_forever
@@ -55,4 +56,4 @@ from funboost.utils.redis_manager import RedisMixin
 # 有的包默认没加handlers，原始的日志不漂亮且不可跳转不知道哪里发生的。这里把warnning级别以上的日志默认加上handlers。
 # nb_log.get_logger(name='', log_level_int=30, log_filename='pywarning.log')
 
-__version__ = "30.2"
+__version__ = "30.4"

{funboost-30.2 → funboost-30.4}/funboost/assist/celery_helper.py

@@ -64,8 +64,8 @@ class CeleryHelper:
         def _f():
             python_executable = sys.executable
             # print(python_executable)
-            # cmd = f'''{python_executable} -m celery -A funboost.publishers.celery_publisher --broker={funboost_config_deafult.CELERY_BROKER_URL}  --result-backend={funboost_config_deafult.CELERY_RESULT_BACKEND}   flower --address=0.0.0.0 --port={port}  --auto_refresh=True '''
-            cmd = f'''{python_executable} -m celery  --broker={BrokerConnConfig.CELERY_BROKER_URL}  --result-backend={BrokerConnConfig.CELERY_RESULT_BACKEND}   flower --address=0.0.0.0 --port={port}  --auto_refresh=True '''
+            # cmd = f'''{python_executable} -m celery -A  funboost.assist.celery_helper  --broker={funboost_config_deafult.CELERY_BROKER_URL}  --result-backend={funboost_config_deafult.CELERY_RESULT_BACKEND}   flower --address=0.0.0.0 --port={port}  --auto_refresh=True '''
+            cmd = f'''{python_executable} -m celery   --broker={BrokerConnConfig.CELERY_BROKER_URL}  --result-backend={BrokerConnConfig.CELERY_RESULT_BACKEND}   flower --address=0.0.0.0 --port={port}  --auto_refresh=True '''
 
             logger.info(f'启动flower命令:   {cmd}')
             os.system(cmd)

{funboost-30.2 → funboost-30.4}/funboost/constant.py

@@ -1,6 +1,7 @@
 # coding= utf-8
 class BrokerEnum:
     RABBITMQ_AMQPSTORM = 0  # 使用 amqpstorm 包操作rabbitmq  作为 分布式消息队列，支持消费确认.强烈推荐这个作为funboost中间件。
+    RABBITMQ = RABBITMQ_AMQPSTORM
 
     RABBITMQ_RABBITPY = 1  # 使用 rabbitpy 包操作rabbitmq  作为 分布式消息队列，支持消费确认。
 
@@ -66,9 +67,10 @@ class BrokerEnum:
 
     PEEWEE = 26  # peewee包操作mysql，使用表模拟消息队列
 
-    REDIS_PUBSUB = 27  # 基于redis 发布订阅的，发布一个消息多个消费者都能收到消息，但不支持持久化
+    REDIS_PUBSUB = 27  # 基于redis 发布订阅的，发布一个消息多个消费者都能收到同一条消息，但不支持持久化
 
-    CELERY = 30  # funboost支持celery框架来发布和消费任务，由celery框架来调度执行任务，但是写法简单暴击celery，永无无需关心和操作Celery对象实例。
+    CELERY = 30  # funboost支持celery框架来发布和消费任务，由celery框架来调度执行任务，但是写法简单远远暴击用户亲自使用celery的麻烦程度，
+                 # 用户永无无需关心和操作Celery对象实例,无需关心celery的task_routes和include配置,funboost来自动化设置这些celery配置。
 
     DRAMATIQ = 31  # funboost使用 dramatiq 框架作为消息队列，dramatiq类似celery也是任务队列框架。用户使用funboost api来操作dramatiq核心调度。
 

{funboost-30.2 → funboost-30.4}/funboost/consumers/base_consumer.py

@@ -20,6 +20,7 @@ import os
 import uuid
 import time
 import traceback
+import inspect
 # from collections import Callable
 from typing import Callable
 from functools import wraps
@@ -437,6 +438,7 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         self._check_broker_exclusive_config()
 
         self._has_start_delay_task_scheduler = False
+        self._consuming_function_is_asyncio = inspect.iscoroutinefunction(self.consuming_function)
         self.custom_init()
 
         atexit.register(self.join_shedual_task_thread)
@@ -801,7 +803,9 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
         t_start = time.time()
         function_result_status.run_times = current_retry_times + 1
         try:
-            function_run = sync_or_async_fun_deco(self.consuming_function)
+            function_run = self.consuming_function
+            if self._consuming_function_is_asyncio:
+                function_run = sync_or_async_fun_deco(function_run)
             function_timeout = self._get_priority_conf(kw, 'function_timeout')
             function_run = function_run if self._consumin_function_decorator is None else self._consumin_function_decorator(function_run)
             function_run = function_run if not function_timeout else self._concurrent_mode_dispatcher.timeout_deco(
@@ -814,14 +818,14 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
                     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)
-            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')
-                # self.error_file_logger.critical(msg=f'{log_msg} \n')
-                self._log_critical(msg=log_msg)
-                # noinspection PyProtectedMember,PyUnresolvedReferences
-
-                os._exit(4)
+            # 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')
+            #     # self.error_file_logger.critical(msg=f'{log_msg} \n')
+            #     self._log_critical(msg=log_msg)
+            #     # noinspection PyProtectedMember,PyUnresolvedReferences
+            #
+            #     os._exit(4)
             function_result_status.success = True
             if self._log_level <= logging.DEBUG:
                 result_str_to_be_print = str(function_result_status.result)[:100] if len(str(function_result_status.result)) < 100 else str(function_result_status.result)[:100] + '  。。。。。  '

{funboost-30.2 → funboost-30.4}/funboost/consumers/confirm_mixin.py

@@ -32,7 +32,7 @@ class ConsumerConfirmMixinWithTheHelpOfRedis(RedisMixin):
         self.keep_circulating(60, block=False)(self._requeue_tasks_which_unconfirmed)()
 
     def _add_task_str_to_unack_zset(self, task_str, ):
-        self.redis_db_frame.zadd(self._unack_zset_name, task_str, time.time())
+        self.redis_db_frame.zadd(self._unack_zset_name, {task_str: time.time()})
 
     def _confirm_consume(self, kw):
         self.redis_db_frame.zrem(self._unack_zset_name, kw['task_str'])

funboost-30.4/funboost/consumers/memory_deque_consumer.py

@@ -0,0 +1,35 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2022/8/8 0008 13:36
+import json
+from collections import deque
+
+from funboost.constant import BrokerEnum
+from funboost.consumers.base_consumer import AbstractConsumer
+from funboost.publishers import meomory_deque_publisher
+
+
+class LocalPythonQueueConsumer(AbstractConsumer):
+    """
+    python 内置queue对象作为消息队列，这个要求发布和消费必须在同一python解释器内部运行，不支持分布式。
+    """
+
+    @property
+    def local_python_queue(self) -> deque:
+        return meomory_deque_publisher.deque_queue_name__deque_obj_map[self._queue_name]
+
+    def _shedual_task(self):
+        while True:
+            task = self.local_python_queue.popleft()
+            if isinstance(task, str):
+                task = json.loads(task)
+            self._print_message_get_from_broker('当前python解释器内部', task)
+            # self.logger.debug(f'从当前python解释器内部的 [{self._queue_name}] 队列中 取出的消息是：  {json.dumps(task)}  ')
+            kw = {'body': task}
+            self._submit_task(kw)
+
+    def _confirm_consume(self, kw):
+        pass
+
+    def _requeue(self, kw):
+        self.local_python_queue.append(kw['body'])

{funboost-30.2 → funboost-30.4}/funboost/consumers/redis_filter.py

@@ -62,7 +62,7 @@ class RedisImpermanencyFilter(RedisFilter):
     """
 
     def add_a_value(self, value: typing.Union[str, dict]):
-        self.redis_db_filter_and_rpc_result.zadd(self._redis_key_name, self._get_ordered_str(value), time.time())
+        self.redis_db_filter_and_rpc_result.zadd(self._redis_key_name, {self._get_ordered_str(value):time.time()})
 
     def manual_delete_a_value(self, value: typing.Union[str, dict]):
         self.redis_db_filter_and_rpc_result.zrem(self._redis_key_name, self._get_ordered_str(value))
@@ -86,6 +86,7 @@ class RedisImpermanencyFilter(RedisFilter):
     @decorators.keep_circulating(60, block=False)
     def delete_expire_filter_task_cycle(self):
         """
+
         一直循环删除过期的过滤任务。任务过滤过期时间最好不要小于60秒，否则删除会不及时,导致发布的新任务不能触发执行。一般实时价格接口是缓存5分钟或30分钟。
         :return:
         """

funboost-30.4/funboost/contrib/api_publish_msg.py

@@ -0,0 +1,54 @@
+import traceback
+
+from funboost import AioAsyncResult, AsyncResult
+
+from funboost.core.cli.discovery_boosters import BoosterDiscovery
+from funboost.core.get_booster import get_booster
+from fastapi import FastAPI
+from pydantic import BaseModel
+
+
+class MsgItem(BaseModel):
+    queue_name: str  # 队列名
+    msg_body: dict  # 消息体,就是boost函数的入参字典,例如 {"x":1,"y":2}
+    need_result: bool = False  # 发布消息后,是否需要返回结果
+    timeout: int = 60  # 等待结果返回的最大等待时间.
+
+
+class PublishResponse(BaseModel):
+    succ: bool
+    msg: str
+    status_and_result: dict = None  # 消费函数的消费状态和结果.
+
+
+# 创建 FastAPI 应用实例
+app = FastAPI()
+
+'''
+如果你在发布消息后还需要获取函数执行结果,
+推荐使用asyncio类型的web框架例如 fastapi tornado,而不是使用flask django,更好的应付由于获取结果而需要的阻塞时间.不使用asyncio的话web框架需要设置开启很高的线程才行.
+'''
+
+
+@app.post("/funboost_publish_msg")
+async def publish_msg(msg_item: MsgItem):
+    status_and_result = None
+    try:
+        booster = get_booster(msg_item.queue_name)
+        if msg_item.need_result:
+            if booster.boost_params['is_using_rpc_mode'] is False:
+                raise ValueError(f' need_result 为true,{booster.queue_name} 队列消费者 需要@boost设置支持rpc模式')
+            async_result = booster.publish(msg_item.msg_body)
+            status_and_result = await AioAsyncResult(async_result.task_id, timeout=msg_item.timeout).status_and_result
+            # status_and_result = AsyncResult(async_result.task_id, timeout=msg_item.timeout).status_and_result
+        return PublishResponse(succ=True, msg=f'{msg_item.queue_name} 队列,消息发布成功', status_and_result=status_and_result)
+    except Exception as e:
+        return PublishResponse(succ=False, msg=f'{msg_item.queue_name} 队列,消息发布失败 {type(e)} {e} {traceback.format_exc()}',
+                               status_and_result=status_and_result)
+
+
+# 运行应用
+if __name__ == "__main__":
+    import uvicorn
+
+    uvicorn.run('funboost.contrib.api_publish_msg:app', host="0.0.0.0", port=16666, workers=4)

{funboost-30.2 → funboost-30.4}/funboost/core/booster.py

@@ -1,6 +1,9 @@
+from __future__ import annotations
 import copy
 import types
 import typing
+
+
 from functools import wraps
 
 from funboost.core.function_result_status_config import FunctionResultStatusPersistanceConfig
@@ -18,7 +21,7 @@ class _Undefined:
 
 class Booster:
     """
-    funboost极其重视代码能在pycharm下自动补全。元编程经常造成在pycharm下代码无法自动补全提示，要是实现代码补全难。
+    funboost极其重视代码能在pycharm下自动补全。元编程经常造成在pycharm下代码无法自动补全提示，主要是实现代码补全难。
     这种__call__写法在pycahrm下 不仅能补全消费函数的 push consume等方法，也能补全函数本身的入参，一举两得。代码能自动补全很重要。
     一个函数fun被 boost装饰器装饰后， isinstance(fun,Booster) 为True.
 
@@ -156,7 +159,7 @@ class Booster:
         else:
             return types.MethodType(self, instance)
 
-    def __call__(self, *args, **kwargs):
+    def __call__(self, *args, **kwargs) -> Booster:
         if len(kwargs) == 0 and len(args) == 1 and isinstance(args[0], typing.Callable):
             consuming_function = args[0]
             self.consuming_function = consuming_function

{funboost-30.2 → funboost-30.4}/funboost/core/cli/funboost_fire.py

@@ -43,6 +43,7 @@ class BoosterFire(object):
     def show_all_queues(self):
         """显示扫描到的所有queue name"""
         print(f'get_all_queues: {get_all_queues()}')
+        return self
 
     def clear(self, *queue_names: str):
         """
@@ -51,6 +52,7 @@ class BoosterFire(object):
 
         for queue_anme in queue_names:
             get_booster(queue_anme).clear()
+        return self
 
     def push(self, queue_anme, *args, **kwargs):
         """push发布消息到消息队列 ;
@@ -60,6 +62,11 @@ class BoosterFire(object):
         或者 push add_queue -x 1 -y 2;
         """
         get_booster(queue_anme).push(*args, **kwargs)
+        return self
+
+    def __str__(self):
+        # print('over')  # 这行重要,否则命令行链式调用无法自动结束
+        return ''
 
     def publish(self, queue_anme, msg):
         """publish发布消息到消息队列;
@@ -68,6 +75,7 @@ class BoosterFire(object):
         """
 
         get_booster(queue_anme).publish(msg)
+        return self
 
     def consume(self, *queue_names: str):
         """
@@ -97,3 +105,10 @@ class BoosterFire(object):
         for queue_anme in queue_names:
             get_booster(queue_anme).pause()
 
+    def continue_consume(self, *queue_names: str):
+        """
+        继续多个消息队列名的消费;
+        例子: continue_consume queue1 queue2
+        """
+        for queue_anme in queue_names:
+            get_booster(queue_anme).continue_consume()

{funboost-30.2 → funboost-30.4}/funboost/core/msg_result_getter.py

@@ -1,4 +1,5 @@
 import asyncio
+import time
 
 import typing
 import json
@@ -141,6 +142,7 @@ if __name__ == '__main__':
     @property
     async def status_and_result(self):
         if not self._has_pop:
+            t1 = time.time()
             redis_value = await self.aioredis_db_filter_and_rpc_result.blpop(self.task_id, self.timeout)
             self._has_pop = True
             if redis_value is not None:

{funboost-30.2 → funboost-30.4}/funboost/factories/broker_kind__publsiher_consumer_type_map.py

@@ -103,7 +103,8 @@ def register_custom_broker(broker_kind, publisher_class: typing.Type[AbstractPub
 def regist_to_funboost(broker_kind: int):
     """
     延迟导入是因为funboost没有pip自动安装这些三方包，防止一启动就报错。
-    这样当用户需要使用某些三方包中间件作为消息队列时候，按照import报错信息，用户自己去pip先安装。或者 pip install funboost[extra_brokers] 一次性安装所有中间件。
+    这样当用户需要使用某些三方包中间件作为消息队列时候，按照import报错信息，用户自己去pip安装好。或者 pip install funboost[all] 一次性安装所有中间件。
+    建议按照 https://github.com/ydf0509/funboost/blob/master/setup.py 中的 extra_brokers 和 install_requires 里面的版本号来安装三方包版本.
     """
 
     if broker_kind == BrokerEnum.PULSAR:
@@ -159,4 +160,5 @@ def regist_to_funboost(broker_kind: int):
 
 if __name__ == '__main__':
     import sys
-    print(sys.modules)
+
+    print(sys.modules)

{funboost-30.2 → funboost-30.4}/funboost/funboost_config_deafult.py

@@ -7,7 +7,7 @@ from funboost.core.function_result_status_config import FunctionResultStatusPers
 from funboost.utils.simple_data_class import DataClassBase
 
 '''
-此文件是第一次运行框架自动生成到你的项目根目录的，不需要用由户手动创建。
+funboost_config.py 文件是第一次运行框架自动生成到你的项目根目录的，不需要用由户手动创建。
 此文件里面可以写任意python代码。例如 中间件 帐号 密码自己完全可以从apola配置中心获取或者从环境变量获取。
 '''
 
@@ -60,7 +60,7 @@ class BrokerConnConfig(DataClassBase):
     MYSQL_PASSWORD = '123456'
     MYSQL_DATABASE = 'testdb6'
 
-    # persist_quque中间件时候采用本机sqlite的方式，数据库文件生成的位置。如果linux账号在根目录没权限建文件夹，可以换文件夹。
+    # persist_quque中间件时候采用本机sqlite的方式，数据库文件生成的位置,如果linux账号在根目录没权限建文件夹，可以换文件夹。
     SQLLITE_QUEUES_PATH = '/sqllite_queues'
 
     TXT_FILE_PATH = Path(__file__).parent / 'txt_queues'  # 不建议使用这个txt模拟消息队列中间件，本地持久化优先选择 PERSIST_QUQUE 中间件。
@@ -88,9 +88,6 @@ class BrokerConnConfig(DataClassBase):
 
 
 class FunboostCommonConfig(DataClassBase):
-    """
-    funboost运行的其它全局默认配置
-    """
     # nb_log包的第几个日志模板，内置了7个模板，可以在你当前项目根目录下的nb_log_config.py文件扩展模板。
     NB_LOG_FORMATER_INDEX_FOR_CONSUMER_AND_PUBLISHER = 11  # 7是简短的不可跳转，5是可点击跳转的，11是可显示ip 进程 线程的模板。
     TIMEZONE = 'Asia/Shanghai'
@@ -113,6 +110,8 @@ class BoostDecoratorDefaultParams(DataClassBase):
     所以boost装饰器只有一个是必传参数。
     """
 
+    broker_kind: int = BrokerEnum.PERSISTQUEUE  # 中间件选型见3.1章节 https://funboost.readthedocs.io/zh/latest/articles/c3.html
+
     concurrent_mode = ConcurrentModeEnum.THREADING
     concurrent_num = 50
     specify_concurrent_pool = None
@@ -151,4 +150,4 @@ class BoostDecoratorDefaultParams(DataClassBase):
 
     broker_exclusive_config = {}
 
-    broker_kind: int = BrokerEnum.PERSISTQUEUE  # 中间件选型见3.1章节 https://funboost.readthedocs.io/zh/latest/articles/c3.html
+

{funboost-30.2 → funboost-30.4}/funboost/function_result_web/app.py

@@ -145,6 +145,7 @@ if __name__ == '__main__':
     app.run(debug=False, threaded=True, host='0.0.0.0', port=27018)
 
     '''
+    linux 是export , win是 set
     # 第一步 export PYTHONPATH=你的项目根目录 ，这么做是为了这个web可以读取到你项目根目录下的 funboost_config.py里面的配置
     # 例如 export PYTHONPATH=/home/ydf/codes/ydfhome
       或者  export PYTHONPATH=./   (./是相对路径，前提是已近cd到你的项目根目录了，也可以写绝对路径全路径)

{funboost-30.2 → funboost-30.4}/funboost/publishers/base_publisher.py

@@ -15,7 +15,6 @@ from functools import wraps
 from threading import Lock
 import datetime
 import amqpstorm
-import decorator_libs
 
 from funboost.utils.develop_log import develop_logger
 

{funboost-30.2 → funboost-30.4}/funboost/publishers/celery_publisher.py

@@ -47,6 +47,7 @@ class CeleryPublisher(AbstractPublisher, ):
         with celery_app.connection_or_acquire() as conn:
             msg_cnt = conn.default_channel.queue_declare(
                 queue=self.queue_name, passive=False,durable=True,auto_delete=False).message_count
+
         return msg_cnt
 
     def close(self):

funboost-30.4/funboost/publishers/local_python_queue_publisher.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2022/8/8 0008 13:07
+from collections import deque
+from queue import Queue, SimpleQueue
+
+from funboost.publishers.base_publisher import AbstractPublisher
+
+local_pyhton_queue_name__local_pyhton_queue_obj_map = dict()  # 使local queue和其他中间件完全一样的使用方式，使用映射保存队列的名字，使消费和发布通过队列名字能找到队列对象。
+
+
+class LocalPythonQueuePublisher(AbstractPublisher):
+    """
+    使用python内置queue对象作为中间件。方便测试，每个中间件的消费者类是鸭子类，多态可以互相替换。
+    """
+
+    # noinspection PyAttributeOutsideInit
+    def custom_init(self):
+        if self._queue_name not in local_pyhton_queue_name__local_pyhton_queue_obj_map:
+            local_pyhton_queue_name__local_pyhton_queue_obj_map[self._queue_name] = Queue(1000000)
+        self.queue = local_pyhton_queue_name__local_pyhton_queue_obj_map[self._queue_name]
+
+    def concrete_realization_of_publish(self, msg):
+        # noinspection PyTypeChecker
+        self.queue.put(msg)
+
+    def clear(self):
+        # noinspection PyUnresolvedReferences
+        self.queue.queue.clear()
+        self.logger.warning(f'清除 本地队列中的消息成功')
+
+    def get_message_count(self):
+        return self.queue.qsize()
+
+    def close(self):
+        pass
+
+
+class LocalPythonQueuePublisherSimpleQueue(AbstractPublisher):
+    """
+    使用python内置SimpleQueue对象作为中间件。方便测试，每个中间件的消费者类是鸭子类，多态可以互相替换。
+    """
+
+    # noinspection PyAttributeOutsideInit
+    def custom_init(self):
+        if self._queue_name not in local_pyhton_queue_name__local_pyhton_queue_obj_map:
+            local_pyhton_queue_name__local_pyhton_queue_obj_map[self._queue_name] = SimpleQueue()
+        self.queue = local_pyhton_queue_name__local_pyhton_queue_obj_map[self._queue_name]  # type: SimpleQueue
+
+    def concrete_realization_of_publish(self, msg):
+        # noinspection PyTypeChecker
+        self.queue.put(msg)
+
+    def clear(self):
+        pass
+        # noinspection PyUnresolvedReferences
+        # self.queue._queue.clear()
+        # self.logger.warning(f'清除 本地队列中的消息成功')
+
+    def get_message_count(self):
+        return self.queue.qsize()
+
+    def close(self):
+        pass
+
+
+class LocalPythonQueuePublisherDeque(AbstractPublisher):
+    """
+    使用python内置 Dequeu 对象作为中间件。方便测试，每个中间件的消费者类是鸭子类，多态可以互相替换。
+    """
+
+    # noinspection PyAttributeOutsideInit
+    def custom_init(self):
+        if self._queue_name not in local_pyhton_queue_name__local_pyhton_queue_obj_map:
+            local_pyhton_queue_name__local_pyhton_queue_obj_map[self._queue_name] = deque()
+        self.queue = local_pyhton_queue_name__local_pyhton_queue_obj_map[self._queue_name]  # type: deque
+        # deque.get = deque.pop
+        # # setattr(self.queue,'get',self.queue.pop)
+
+    def concrete_realization_of_publish(self, msg):
+        # noinspection PyTypeChecker
+        print(msg)
+        self.queue.append(msg)
+
+    def clear(self):
+        pass
+        # noinspection PyUnresolvedReferences
+        self.queue.clear()
+        self.logger.warning(f'清除 本地队列中的消息成功')
+
+    def get_message_count(self):
+        return len(self.queue)
+
+    def close(self):
+        pass

funboost-30.4/funboost/publishers/meomory_deque_publisher.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2022/8/8 0008 13:07
+from collections import deque
+
+from funboost.publishers.base_publisher import AbstractPublisher
+
+deque_queue_name__deque_obj_map = dict()  # 使local queue和其他中间件完全一样的使用方式，使用映射保存队列的名字，使消费和发布通过队列名字能找到队列对象。
+
+
+class DequePublisher(AbstractPublisher):
+    """
+    使用python内置queue对象作为中间件。方便测试，每个中间件的消费者类是鸭子类，多态可以互相替换。
+    """
+
+    # noinspection PyAttributeOutsideInit
+    def custom_init(self):
+        if self._queue_name not in deque_queue_name__deque_obj_map:
+            deque_queue_name__deque_obj_map[self._queue_name] = deque()
+        self.queue = deque_queue_name__deque_obj_map[self._queue_name]  # type: deque
+
+    def concrete_realization_of_publish(self, msg):
+        # noinspection PyTypeChecker
+        self.queue.append(msg)
+
+    def clear(self):
+        pass
+        # noinspection PyUnresolvedReferences
+        self.queue.clear()
+        self.logger.warning(f'清除 本地队列中的消息成功')
+
+    def get_message_count(self):
+        return len(self.queue)
+
+    def close(self):
+        pass

{funboost-30.2 → funboost-30.4}/funboost/timing_job/__init__.py

@@ -19,7 +19,7 @@ from apscheduler.util import undefined
 import deprecated
 from funboost.utils.redis_manager import RedisMixin
 
-from funboost.funboost_config_deafult import BrokerConnConfig,FunboostCommonConfig
+from funboost.funboost_config_deafult import BrokerConnConfig, FunboostCommonConfig
 
 from funboost.consumers.base_consumer import AbstractConsumer
 from funboost.core.get_booster import get_booster, Booster
@@ -39,12 +39,12 @@ def timing_publish_deco(consuming_func_decorated_or_consumer: Union[callable, Ab
     return _deco
 
 
-def push_fun_params_to_broker(queue_name: str, *args, **kwargs, ):
+def push_fun_params_to_broker(queue_name: str, *args, runonce_uuid=None, **kwargs):
     """
+    queue_name 队列名字
     *args **kwargs 是消费函数的入参
+    发布消息中可以包括,runonce_uuid这个入参,确保分布式多个脚本都启动了定时器,导致每个定时器重复发布到消息队列,值你自己写  str(uuid.uuid4())
     """
-    runonce_uuid = kwargs['runonce_uuid']
-    kwargs.pop('runonce_uuid')
     if runonce_uuid:
         key = 'apscheduler.redisjobstore_runonce2'
         if RedisMixin().redis_db_frame.sadd(key, runonce_uuid):
@@ -69,10 +69,11 @@ class FunboostBackgroundScheduler(BackgroundScheduler):
                             next_run_time, jobstore, executor,
                             replace_existing, **trigger_args)
 
-    def add_push_job(self, func: Booster, trigger=None, args=None, kwargs=None, id=None, name=None,
+    def add_push_job(self, func: Booster, trigger=None, args=None, kwargs=None, runonce_uuid=None,
+                     id=None, name=None,
                      misfire_grace_time=undefined, coalesce=undefined, max_instances=undefined,
                      next_run_time=undefined, jobstore='default', executor='default',
-                     replace_existing=False, runonce_uuid=None, **trigger_args, ):
+                     replace_existing=False, **trigger_args, ):
         """
         :param func: 被@boost装饰器装饰的函数
         :param trigger:
@@ -162,7 +163,7 @@ fsdf_background_scheduler = funboost_aps_scheduler  # 兼容一下老名字。
 if __name__ == '__main__':
     # 定时运行消费演示
     import datetime
-    from funboost import boost, BrokerEnum, fsdf_background_scheduler, timing_publish_deco, run_forever, Booster
+    from funboost import boost, BrokerEnum, fsdf_background_scheduler, timing_publish_deco, run_forever
 
 
     @Booster('queue_test_666', broker_kind=BrokerEnum.LOCAL_PYTHON_QUEUE)
@@ -171,6 +172,7 @@ if __name__ == '__main__':
 
 
     print(consume_func, type(consume_func))
+
     # 定时每隔3秒执行一次。
     funboost_aps_scheduler.add_push_job(consume_func,
                                         'interval', id='3_second_job', seconds=3, kwargs={"x": 5, "y": 6})