funboost 49.4__tar.gz → 49.6__tar.gz

{funboost-49.4/funboost.egg-info → funboost-49.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: funboost
-Version: 49.4
+Version: 49.6
 Summary: pip install funboost，python全功能分布式函数调度框架,funboost的功能是全面性重量级，用户能想得到的功能99%全都有;funboost的使用方式是轻量级，只有@boost一行代码需要写。支持python所有类型的并发模式和一切知名消息队列中间件，支持如 celery dramatiq等框架整体作为funboost中间件，python函数加速器，框架包罗万象，用户能想到的控制功能全都有。一统编程思维，兼容50% python业务场景，适用范围广。只需要一行代码即可分布式执行python一切函数，funboost web manager 方便查看和管理消费函数；99%用过funboost的pythoner 感受是　简易 方便 强劲 强大，相见恨晚 
 Home-page: https://github.com/ydf0509/funboost
 Author: bfzs
@@ -24,6 +24,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Software Development :: Libraries
 Description-Content-Type: text/markdown
@@ -73,9 +74,9 @@ Broker。funboost源码高扩展性的设计，造成“万物皆可为Broker”
 框架对代码没有入侵,可以加到任意已有项目而对项目python文件目录结构0要求,
 不像 celery django scrapy 这样的框架,要从一开始就开始规划好项目目录结构,如果不想用框架了,
 或者想改变使用其他框架框架,那么已经所写的代码组织形式就几乎成了废物,需要大改特改. 
-但是funboost完全不会这样,就算是加上或去掉@boost装饰器,对你的项目影响为0,用户照常使用,
+但是funboost完全不会这样,不管是加上还是去掉@boost装饰器,对你的项目影响为0,用户照常使用,
 所以用户可以对任意项目,任意时候,引入使用funboost或者去掉使用funboost,代码组织形式不需要发生变化.
-（即使不想用funboost了，也不需要亲自去掉@boost装饰器，因为函数有@boost装饰器对函数自身的直接调用运行没有任何影响，
+（即使不想用funboost了，也不需要亲自去掉@boost装饰器，因为函数上面有@boost装饰器对函数自身的直接调用运行没有任何影响，
 用户照样可以直接例如 fun(x,y)是直接运行函数 ， fun.push(x,y) 才是发送到消息队列）
 
 通过funboost web manager 管理系统，支持全面 查看 监控 管理 funboost的任务消费。

{funboost-49.4 → funboost-49.6}/README.md

@@ -39,9 +39,9 @@ Broker。funboost源码高扩展性的设计，造成“万物皆可为Broker”
 框架对代码没有入侵,可以加到任意已有项目而对项目python文件目录结构0要求,
 不像 celery django scrapy 这样的框架,要从一开始就开始规划好项目目录结构,如果不想用框架了,
 或者想改变使用其他框架框架,那么已经所写的代码组织形式就几乎成了废物,需要大改特改. 
-但是funboost完全不会这样,就算是加上或去掉@boost装饰器,对你的项目影响为0,用户照常使用,
+但是funboost完全不会这样,不管是加上还是去掉@boost装饰器,对你的项目影响为0,用户照常使用,
 所以用户可以对任意项目,任意时候,引入使用funboost或者去掉使用funboost,代码组织形式不需要发生变化.
-（即使不想用funboost了，也不需要亲自去掉@boost装饰器，因为函数有@boost装饰器对函数自身的直接调用运行没有任何影响，
+（即使不想用funboost了，也不需要亲自去掉@boost装饰器，因为函数上面有@boost装饰器对函数自身的直接调用运行没有任何影响，
 用户照样可以直接例如 fun(x,y)是直接运行函数 ， fun.push(x,y) 才是发送到消息队列）
 
 通过funboost web manager 管理系统，支持全面 查看 监控 管理 funboost的任务消费。

{funboost-49.4 → funboost-49.6}/funboost/__init__.py

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

{funboost-49.4 → funboost-49.6}/funboost/beggar_version_implementation/beggar_redis_consumer.py

@@ -19,7 +19,9 @@ from concurrent.futures import ThreadPoolExecutor
 from funboost.funboost_config_deafult import BrokerConnConfig
 
 redis_db_frame = redis.Redis(host=BrokerConnConfig.REDIS_HOST, password=BrokerConnConfig.REDIS_PASSWORD,
-                             port=BrokerConnConfig.REDIS_PORT, db=BrokerConnConfig.REDIS_DB, decode_responses=True)
+                             port=BrokerConnConfig.REDIS_PORT, db=BrokerConnConfig.REDIS_DB,
+                             ssl=BrokerConnConfig.REDIS_USE_SSL,
+                             decode_responses=True)
 
 
 class BeggarRedisConsumer:

{funboost-49.4 → funboost-49.6}/funboost/constant.py

@@ -10,12 +10,21 @@ class BrokerEnum:
 
     RABBITMQ_RABBITPY = 'RABBITMQ_RABBITPY'  # 使用 rabbitpy 包操作rabbitmq  作为 分布式消息队列，支持消费确认，不建议使用
 
+    """
+    以下是各种redis数据结构和各种方式来实现作为消息队列的,redis简直被作者玩出花来了.
+    因为redis本身是缓存数据库,不是消息队列,redis没有实现经典AMQP协议,所以redis是模拟消息队列不是真消息队列.
+    例如要实现消费确认,随意重启但消息万无一失,你搞个简单的 redis.blpop 弹出删除消息,那就压根不行.重启就丢失了,但消息可能还没开始运行或者正在运行中.
+    
+    redis做ack挑战难点不是怎么实现确认消费本身,而是何时应该把关闭或宕机进程的消费者的待确认消费的孤儿消息重回队列.  
+    在 Redis 上实现 ACK 的真正难点，根本不在于“确认”这个动作本身，而在于建立一套可靠的、能够准确判断“何时可以安全地及时地进行任务恢复”的分布式故障检测机制。
+    所以你以为只要使用 brpoplpush 或者 REDIS_STREAM 就能自动轻易解决ack问题,那就太天真了,因为redis服务端不能像rabbitmq服务端那样天生自带自动重回宕机消费者的消息机制,需要你在redis客户端来维护实现这套机制.
+    """
     REDIS = 'REDIS'  # 使用 redis 的 list结构，brpop 作为分布式消息队列。随意重启和关闭会丢失大量消息，不支持消费确认。注重性能不在乎丢失消息可以选这个redis方案。
     REDIS_ACK_ABLE = 'REDIS_ACK_ABLE'  # 基于redis的 list + 临时unack的set队列，采用了 lua脚本操持了取任务和加到pengding为原子性，,基于进程心跳消失判断消息是否为掉线进程的，随意重启和掉线不会丢失任务。
-    REIDS_ACK_USING_TIMEOUT = 'reids_ack_using_timeout'  # 基于redis的 list + 临时unack的set队列，使用超时多少秒没确认消费就自动重回队列，请注意 ack_timeout的设置值和函数耗时大小，否则会发生反复重回队列的后果,boost可以设置ack超时，broker_exclusive_config={'ack_timeout': 1800}
+    REIDS_ACK_USING_TIMEOUT = 'reids_ack_using_timeout'  # 基于redis的 list + 临时unack的set队列，使用超时多少秒没确认消费就自动重回队列，请注意 ack_timeout的设置值和函数耗时大小，否则会发生反复重回队列的后果,boost可以设置ack超时，broker_exclusive_config={'ack_timeout': 1800}.缺点是无法区分执行太慢还是真宕机
     REDIS_PRIORITY = 'REDIS_PRIORITY'  # # 基于redis的多 list + 临时unack的set队列，blpop监听多个key，和rabbitmq的x-max-priority属性一样，支持任务优先级。看文档4.29优先级队列说明。
     REDIS_STREAM = 'REDIS_STREAM'  # 基于redis 5.0 版本以后，使用 stream 数据结构作为分布式消息队列，支持消费确认和持久化和分组消费，是redis官方推荐的消息队列形式，比list结构更适合。
-    RedisBrpopLpush = 'RedisBrpopLpush'  # 基于redis的list结构但是采用brpoplpush 双队列形式，和 redis_ack_able的实现差不多，实现上采用了原生命令就不需要lua脚本来实现取出和加入unack了。
+    RedisBrpopLpush = 'RedisBrpopLpush'  # 基于redis的list结构但是采用 brpoplpush 双队列形式，和 redis_ack_able的实现差不多，实现上采用了原生命令就不需要lua脚本来实现取出和加入unack了。
     REDIS_PUBSUB = 'REDIS_PUBSUB'  # 基于redis 发布订阅的，发布一个消息多个消费者都能收到同一条消息，但不支持持久化
 
     MEMORY_QUEUE = 'MEMORY_QUEUE'  # 使用python queue.Queue实现的基于当前python进程的消息队列，不支持跨进程 跨脚本 跨机器共享任务，不支持持久化，适合一次性短期简单任务。
@@ -44,8 +53,15 @@ class BrokerEnum:
 
     ZEROMQ = 'ZEROMQ'  # 基于zeromq作为分布式消息队列，不需要安装中间件，可以支持跨机器但不支持持久化。
 
+
     """
-    操作 kombu 包，这个包也是celery的中间件依赖包，这个包可以操作10种中间件(例如rabbitmq redis)，但没包括分布式函数调度框架的kafka nsq zeromq 等。
+    kombu 和 celery 都是 funboost中的神级别broker_kind。
+    使得funboost以逸待劳，支持kombu的所有现有和未来的消息队列。
+    通过直接支持 kombu，funboost 相当于一瞬间就继承了 `kombu` 支持的所有现有和未来的消息队列能力。无论 kombu 社区未来增加了对哪种新的云消息服务（如 Google
+    Pub/Sub、Azure Service Bus）或小众 MQ 的支持，funboost 无需修改自身代码，就能自动获得这种能力。这
+    是一种“以逸待劳”的策略，极大地扩展了 funboost 的适用范围。
+
+    kombu 包可以作为funboost的broker，这个包也是celery的中间件依赖包，这个包可以操作10种中间件(例如rabbitmq redis)，但没包括分布式函数调度框架的kafka nsq zeromq 等。
     同时 kombu 包的性能非常差，可以用原生redis的lpush和kombu的publish测试发布，使用brpop 和 kombu 的 drain_events测试消费，对比差距相差了5到10倍。
     由于性能差，除非是分布式函数调度框架没实现的中间件才选kombu方式(例如kombu支持亚马逊队列  qpid pyro 队列)，否则强烈建议使用此框架的操作中间件方式而不是使用kombu。
     """
@@ -74,6 +90,7 @@ class BrokerEnum:
 
     CELERY = 'CELERY'  # funboost支持celery框架来发布和消费任务，由celery框架来调度执行任务，但是写法简单远远暴击用户亲自使用celery的麻烦程度，
     # 用户永无无需关心和操作Celery对象实例,无需关心celery的task_routes和includes配置,funboost来自动化设置这些celery配置。
+    # funboost将Celery本身纳入了自己的Broker体系。能“吞下”另一个大型框架，简直太妙了。本身就证明了funboost架构的包容性和精妙性和复杂性。
 
     DRAMATIQ = 'DRAMATIQ'  # funboost使用 dramatiq 框架作为消息队列，dramatiq类似celery也是任务队列框架。用户使用funboost api来操作dramatiq核心调度。
 

{funboost-49.4 → funboost-49.6}/funboost/consumers/base_consumer.py

@@ -437,6 +437,13 @@ class AbstractConsumer(LoggerLevelSetterMixin, metaclass=abc.ABCMeta, ):
     def _shedual_task(self):
         """
         每个子类必须实现这个的方法，完成如何从中间件取出消息，并将函数和运行参数添加到工作池。
+
+        funboost 的 _shedual_task 哲学是：“我不管你怎么从你的系统里拿到任务，我只要求你拿到任务后，
+        调用 self._submit_task(msg) 方法把它交给我处理就行。”
+
+        所以无论获取消息是 拉模式 还是推模式 还是轮询模式，无论是是单条获取 还是多条批量多条获取，
+        都能轻松扩展任意东西作为funboost的中间件。 
+
         :return:
         """
         raise NotImplementedError

{funboost-49.4 → funboost-49.6}/funboost/consumers/celery_consumer.py

@@ -197,6 +197,7 @@ class CeleryConsumer(AbstractConsumer):
             time.sleep(100)
 
     def _confirm_consume(self, kw):
+        """完全由celery框架接管控制消费和ack确认消费，不需要funboost自己的代码来执行"""
         pass
 
     def _requeue(self, kw):

funboost-49.6/funboost/consumers/empty_consumer.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+# @Author  : ydf
+# @Time    : 2023/8/8 0008 13:32
+
+import abc
+from funboost.consumers.base_consumer import AbstractConsumer
+
+
+class EmptyConsumer(AbstractConsumer, metaclass=abc.ABCMeta):
+    """
+    一个空的消费者基类，作为自定义 Broker 的模板。
+
+    这个类其实是多余的，因为用户完全可以继承AbstractConsumer，然后实现custom_init方法，然后实现_shedual_task, _confirm_consume, _requeue方法来新增自定义broker。
+    这个类是为了清晰明确的告诉你，仅仅需要下面三个方法，就可以实现一个自定义broker，因为AbstractConsumer基类功能太丰富了，基类方法是在太多了，用户不知道需要继承重写哪方法
+    
+    
+    """
+    def custom_init(self):
+        pass
+
+    @abc.abstractmethod
+    def _shedual_task(self):
+        """
+        核心调度任务。此方法需要实现一个循环，负责从你的中间件中获取消息，
+        然后调用 `self._submit_task(msg)` 将任务提交到框架的并发池中执行。 可以参考funboos源码中的各种消费者实现。
+        """
+        raise NotImplemented('not realization')
+
+    @abc.abstractmethod
+    def _confirm_consume(self, kw):
+        """确认消费，就是ack概念"""
+        raise NotImplemented('not realization')
+
+    @abc.abstractmethod
+    def _requeue(self, kw):
+        """重新入队"""
+        raise NotImplemented('not realization')

{funboost-49.4 → funboost-49.6}/funboost/consumers/kombu_consumer.py

@@ -17,55 +17,6 @@ from kombu.transport.redis import Empty
 from funboost.consumers.base_consumer import AbstractConsumer
 from funboost.funboost_config_deafult import BrokerConnConfig
 
-def patch_kombu_redis000():
-    # 这个也可以，代码长了一点。
-    """
-    给kombu的redis 模式打猴子补丁
-    kombu有bug，redis中间件 unnacked 中的任务即使客户端掉线了或者突然关闭脚本中正在运行的任务，也永远不会被重新消费。
-    这个很容易验证那个测试，把消费函数写成sleep 100秒，启动20秒后把脚本关掉，取出来的任务在 unacked 队列中那个永远不会被确认消费，也不会被重新消费。
-    """
-
-    # noinspection PyUnusedLocal
-    def monkey_get(self, callback, timeout=None):
-        self._in_protected_read = True
-        try:
-            for channel in self._channels:
-                if channel.active_queues:  # BRPOP mode?
-                    if channel.qos.can_consume():
-                        self._register_BRPOP(channel)
-                if channel.active_fanout_queues:  # LISTEN mode?
-                    self._register_LISTEN(channel)
-
-            events = self.poller.poll(timeout)
-            if events:
-                for fileno, event in events:
-                    ret = None
-                    # noinspection PyBroadException,PyUnusedLocal
-                    try:
-                        ret = self.handle_event(fileno, event)  # 主要是这行改了加了try，不然会raise empty 导致self.maybe_restore_messages()没执行
-                    except BaseException as e:
-                        pass
-                        # print(traceback.format_exc())
-                        # print(e)
-                    if ret:
-                        return
-            # - no new data, so try to restore messages.
-            # - reset active redis commands.
-            self.maybe_restore_messages()
-            raise Empty()
-            # raise Exception('kombu.five.Empty')
-        finally:
-            self._in_protected_read = False
-            # print(self.after_read)
-            while self.after_read:
-                try:
-                    fun = self.after_read.pop()
-                except KeyError:
-                    break
-                else:
-                    fun()
-
-    redis.MultiChannelPoller.get = monkey_get
 
 
 has_patch_kombu_redis = False
@@ -211,7 +162,6 @@ Transport Options
                 self.conn.drain_events()
 
     def _confirm_consume(self, kw):
-        pass  # redis没有确认消费的功能。
         kw['message'].ack()
 
     def _requeue(self, kw):

{funboost-49.4 → funboost-49.6}/funboost/consumers/rabbitmq_amqpstorm_consumer.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 # @Author  : ydf
 # @Time    : 2022/8/8 0008 13:30
-import json
+
 import amqpstorm
 from funboost.constant import BrokerEnum
 from funboost.consumers.base_consumer import AbstractConsumer

{funboost-49.4 → funboost-49.6}/funboost/funboost_config_deafult.py

@@ -44,7 +44,8 @@ class BrokerConnConfig(DataClassBase):
     REDIS_PORT = 6379
     REDIS_DB = 7  # redis消息队列所在db，请不要在这个db放太多其他键值对，以及方便你自己可视化查看你的redis db，框架里面有的功能会scan扫描unacked的键名，使用单独的db。
     REDIS_DB_FILTER_AND_RPC_RESULT = 8  # 如果函数做任务参数过滤 或者使用rpc获取结果，使用这个db，因为这个db的键值对多，和redis消息队列db分开
-    REDIS_URL = f'redis://{REDIS_USERNAME}:{REDIS_PASSWORD}@{REDIS_HOST}:{REDIS_PORT}/{REDIS_DB}'
+    REDIS_SSL = False
+    REDIS_URL = f'{"rediss" if REDIS_SSL else "redis"}://{REDIS_USERNAME}:{REDIS_PASSWORD}@{REDIS_HOST}:{REDIS_PORT}/{REDIS_DB}'
 
     NSQD_TCP_ADDRESSES = ['127.0.0.1:4150']
     NSQD_HTTP_CLIENT_HOST = '127.0.0.1'

{funboost-49.4 → funboost-49.6}/funboost/timing_job/apscheduler_use_redis_store.py

@@ -1,5 +1,5 @@
 from apscheduler.jobstores.redis import RedisJobStore
-from funboost.utils.redis_manager import RedisMixin
+from funboost.utils.redis_manager import RedisMixin,get_redis_conn_kwargs
 
 from funboost.timing_job import FunboostBackgroundScheduler
 from funboost.funboost_config_deafult import BrokerConnConfig, FunboostCommonConfig
@@ -41,6 +41,21 @@ class FunboostBackgroundSchedulerProcessJobsWithinRedisLock(FunboostBackgroundSc
     #     return 0.1
 
     def _process_jobs(self):
+        """
+        funboost 的做法是 在任务取出阶段就加锁，从根本上防止了重复执行。
+        这个很关键，防止多个apscheduler 实例同时扫描取出同一个定时任务，间接导致重复执行,
+        在apscheduler 3.xx版本这样写来防止多个apscheduler实例 重复执行定时任务的问题,简直是神操作.
+
+        _process_jobs 功能是扫描取出需要运行的定时任务,而不是直接运行定时任务
+        只要扫描取出任务不会取出相同的任务,就间接的决定了不可能重复执行相同的定时任务了.
+        
+
+        不要以为随便在你自己的消费函数加个redis分布式锁就不会重复执行任务了,redis分布式锁是解决相同代码块不会并发执行,而不是解决重复执行.
+        但funboost是神级别骚操作,把分布式锁加到_process_jobs里面,
+        _process_jobs是获取一个即将运行的定时任务,是扫描并删除这个即将运行的定时任务,
+        所以这里加分布式锁能间接解决不重复运行定时任务,一旦任务被取出，就会从 jobstore 中删除,其他实例就无法再取到这个任务了.
+
+        """
         if self.process_jobs_redis_lock_key is None:
             raise ValueError('process_jobs_redis_lock_key is not set')
         with RedisDistributedBlockLockContextManager(RedisMixin().redis_db_frame, self.process_jobs_redis_lock_key, ):
@@ -48,9 +63,8 @@ class FunboostBackgroundSchedulerProcessJobsWithinRedisLock(FunboostBackgroundSc
 
 
 jobstores = {
-    "default": RedisJobStore(db=BrokerConnConfig.REDIS_DB, host=BrokerConnConfig.REDIS_HOST,
-                             port=BrokerConnConfig.REDIS_PORT, password=BrokerConnConfig.REDIS_PASSWORD,
-                             username=BrokerConnConfig.REDIS_USERNAME, jobs_key='funboost.apscheduler.jobs',run_times_key="funboost.apscheduler.run_times")
+    "default": RedisJobStore(**get_redis_conn_kwargs(),
+                             jobs_key='funboost.apscheduler.jobs',run_times_key="funboost.apscheduler.run_times")
 }
 
 """

{funboost-49.4 → funboost-49.6}/funboost/utils/__init__.py

@@ -5,7 +5,7 @@
 
 from funboost.utils.dependency_packages_in_pythonpath import add_to_pythonpath
 
-from nb_log import (LogManager, simple_logger, defaul_logger, LoggerMixin, LoggerLevelSetterMixin,
+from nb_log import (LogManager, simple_logger, LoggerMixin, LoggerLevelSetterMixin,
                     LoggerMixinDefaultWithFileHandler,nb_print,patch_print,reverse_patch_print,get_logger)
 
 # from funboost.utils.redis_manager import RedisMixin

{funboost-49.4 → funboost-49.6}/funboost/utils/ctrl_c_end.py

@@ -16,7 +16,7 @@ def ctrl_c_recv():
     apscheduler background 类型必须有主线程在运行，否则会很快结束。所以需要阻止主线程退出。
     在代码最最末尾加上 ctrl_c_recv() 就可以阻止主线程退出。
     
-    你也可以直接在你的启动脚本的最末尾加上：
+    你也可以不用ctrl_c_recv(),  直接在你的启动脚本文件的最末尾加上：
     while 1:
         time.sleep(100) 
     来达到阻止主线程退出的目的。

{funboost-49.4 → funboost-49.6}/funboost/utils/redis_manager.py

@@ -13,7 +13,7 @@ from funboost.utils import decorators
 
 def get_redis_conn_kwargs():
     return {'host': BrokerConnConfig.REDIS_HOST, 'port': BrokerConnConfig.REDIS_PORT,
-            'username': BrokerConnConfig.REDIS_USERNAME,
+            'username': BrokerConnConfig.REDIS_USERNAME,'ssl' : BrokerConnConfig.REDIS_SSL,
             'password': BrokerConnConfig.REDIS_PASSWORD, 'db': BrokerConnConfig.REDIS_DB}
 
 
@@ -26,11 +26,13 @@ def _get_redis_conn_kwargs_by_db(db):
 class RedisManager(object):
     _redis_db__conn_map = {}
 
-    def __init__(self, host='127.0.0.1', port=6379, db=0, username='', password=''):
-        self._key = (host, port, db, username, password,)
+    def __init__(self, host='127.0.0.1', port=6379, db=0, username='', password='',ssl=False):
+        self._key = (host, port, db, username, password,ssl)
         if self._key not in self.__class__._redis_db__conn_map:
             self.__class__._redis_db__conn_map[self._key] = redis5.Redis(host=host, port=port, db=db, username=username,
-                                                                         password=password, max_connections=1000, decode_responses=True)
+                                                                         password=password, max_connections=1000,
+                                                                         ssl=ssl,
+                                                                         decode_responses=True)
         self.redis = self.__class__._redis_db__conn_map[self._key]
 
     def get_redis(self) -> redis5.Redis:

{funboost-49.4 → funboost-49.6/funboost.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: funboost
-Version: 49.4
+Version: 49.6
 Summary: pip install funboost，python全功能分布式函数调度框架,funboost的功能是全面性重量级，用户能想得到的功能99%全都有;funboost的使用方式是轻量级，只有@boost一行代码需要写。支持python所有类型的并发模式和一切知名消息队列中间件，支持如 celery dramatiq等框架整体作为funboost中间件，python函数加速器，框架包罗万象，用户能想到的控制功能全都有。一统编程思维，兼容50% python业务场景，适用范围广。只需要一行代码即可分布式执行python一切函数，funboost web manager 方便查看和管理消费函数；99%用过funboost的pythoner 感受是　简易 方便 强劲 强大，相见恨晚 
 Home-page: https://github.com/ydf0509/funboost
 Author: bfzs
@@ -24,6 +24,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Topic :: Software Development :: Libraries
 Description-Content-Type: text/markdown
@@ -73,9 +74,9 @@ Broker。funboost源码高扩展性的设计，造成“万物皆可为Broker”
 框架对代码没有入侵,可以加到任意已有项目而对项目python文件目录结构0要求,
 不像 celery django scrapy 这样的框架,要从一开始就开始规划好项目目录结构,如果不想用框架了,
 或者想改变使用其他框架框架,那么已经所写的代码组织形式就几乎成了废物,需要大改特改. 
-但是funboost完全不会这样,就算是加上或去掉@boost装饰器,对你的项目影响为0,用户照常使用,
+但是funboost完全不会这样,不管是加上还是去掉@boost装饰器,对你的项目影响为0,用户照常使用,
 所以用户可以对任意项目,任意时候,引入使用funboost或者去掉使用funboost,代码组织形式不需要发生变化.
-（即使不想用funboost了，也不需要亲自去掉@boost装饰器，因为函数有@boost装饰器对函数自身的直接调用运行没有任何影响，
+（即使不想用funboost了，也不需要亲自去掉@boost装饰器，因为函数上面有@boost装饰器对函数自身的直接调用运行没有任何影响，
 用户照样可以直接例如 fun(x,y)是直接运行函数 ， fun.push(x,y) 才是发送到消息队列）
 
 通过funboost web manager 管理系统，支持全面 查看 监控 管理 funboost的任务消费。

{funboost-49.4 → funboost-49.6}/funboost.egg-info/requires.txt

@@ -1,4 +1,4 @@
-nb_log>=13.2
+nb_log>=13.7
 nb_libs>=1.9
 nb_time>=2.4
 pymongo>=4.6.3

{funboost-49.4 → funboost-49.6}/setup.py

@@ -70,7 +70,7 @@ setup(
         'Programming Language :: Python :: 3.11',
         'Programming Language :: Python :: 3.12',
         'Programming Language :: Python :: 3.13',
-        # 'Programming Language :: Python :: 3.14',
+        'Programming Language :: Python :: 3.14',
         # 'Programming Language :: Python :: 3.15',
         # 'Programming Language :: Python :: 3.16',
         # 'Programming Language :: Python :: 3.17',
@@ -82,7 +82,7 @@ setup(
         'Topic :: Software Development :: Libraries'
     ],
     install_requires=[
-        'nb_log>=13.2',
+        'nb_log>=13.7',
         'nb_libs>=1.9',
         'nb_time>=2.4',
         "pymongo>=4.6.3",  # 3.5.1  -> 4.0.2

funboost-49.4/funboost/consumers/empty_consumer.py

@@ -1,26 +0,0 @@
-# -*- coding: utf-8 -*-
-# @Author  : ydf
-# @Time    : 2023/8/8 0008 13:32
-
-import abc
-from funboost.consumers.base_consumer import AbstractConsumer
-
-
-class EmptyConsumer(AbstractConsumer, metaclass=abc.ABCMeta):
-    """
-    空的消费者没实现，空的实现，需要搭配 boost入参的 consumer_override_cls 和 publisher_override_cls使用，或者被继承。
-    """
-    def custom_init(self):
-        pass
-
-    @abc.abstractmethod
-    def _shedual_task(self):
-        raise NotImplemented('not realization')
-
-    @abc.abstractmethod
-    def _confirm_consume(self, kw):
-        raise NotImplemented('not realization')
-
-    @abc.abstractmethod
-    def _requeue(self, kw):
-        raise NotImplemented('not realization')