funboost 48.8__py3-none-any.whl → 49.0__py3-none-any.whl

funboost/core/func_params_model.py

@@ -127,17 +127,18 @@ class BoosterParams(BaseJsonAbleModel):
     """
 
     queue_name: str  # 队列名字,必传项,每个函数要使用不同的队列名字.
+    broker_kind: str = BrokerEnum.SQLITE_QUEUE  # 中间件选型见3.1章节 https://funboost.readthedocs.io/zh-cn/latest/articles/c3.html
 
     """如果设置了qps，并且cocurrent_num是默认的50，会自动开了500并发，由于是采用的智能线程池任务少时候不会真开那么多线程而且会自动缩小线程数量。具体看ThreadPoolExecutorShrinkAble的说明
     由于有很好用的qps控制运行频率和智能扩大缩小的线程池，此框架建议不需要理会和设置并发数量只需要关心qps就行了，框架的并发是自适应并发数量，这一点很强很好用。"""
     concurrent_mode: str = ConcurrentModeEnum.THREADING  # 并发模式,支持THREADING,GEVENT,EVENTLET,ASYNC,SINGLE_THREAD并发,multi_process_consume 支持协程/线程 叠加多进程并发,性能炸裂.
     concurrent_num: int = 50  # 并发数量，并发种类由concurrent_mode决定
     specify_concurrent_pool: typing.Optional[FunboostBaseConcurrentPool] = None  # 使用指定的线程池/携程池，可以多个消费者共使用一个线程池,节约线程.不为None时候。threads_num失效
-    specify_async_loop: asyncio.AbstractEventLoop = None  # 指定的async的loop循环，设置并发模式为async才能起作用。 有些包例如aiohttp,请求和httpclient的实例化不能处在两个不同的loop中,可以传过来.
+    specify_async_loop: typing.Optional[asyncio.AbstractEventLoop] = None  # 指定的async的loop循环，设置并发模式为async才能起作用。 有些包例如aiohttp,发送请求和httpclient的实例化不能处在两个不同的loop中,可以传过来.
 
     """qps:
     强悍的控制功能,指定1秒内的函数执行次数，例如可以是小数0.01代表每100秒执行一次，也可以是50代表1秒执行50次.为None则不控频。 设置qps时候,不需要指定并发数量,funboost的能够自适应智能动态调节并发池大小."""
-    qps: typing.Union[float, int] = None
+    qps: typing.Union[float, int, None] = None
     """is_using_distributed_frequency_control:
     是否使用分布式空频（依赖redis统计消费者数量，然后频率平分），默认只对当前实例化的消费者空频有效。假如实例化了2个qps为10的使用同一队列名的消费者，并且都启动，则每秒运行次数会达到20。
     如果使用分布式空频则所有消费者加起来的总运行次数是10。"""
@@ -155,7 +156,7 @@ class BoosterParams(BaseJsonAbleModel):
     is_push_to_dlx_queue_when_retry_max_times: bool = False  # 函数达到最大重试次数仍然没成功，是否发送到死信队列,死信队列的名字是 队列名字 + _dlx。
 
 
-    consumin_function_decorator: typing.Callable = None  # 函数的装饰器。因为此框架做参数自动转指点，需要获取精准的入参名称，不支持在消费函数上叠加 @ *args  **kwargs的装饰器，如果想用装饰器可以这里指定。
+    consumin_function_decorator: typing.Optional[typing.Callable] = None  # 函数的装饰器。因为此框架做参数自动转指点，需要获取精准的入参名称，不支持在消费函数上叠加 @ *args  **kwargs的装饰器，如果想用装饰器可以这里指定。
     function_timeout: typing.Union[int, float,None] = None  # 超时秒数，函数运行超过这个时间，则自动杀死函数。为0是不限制。 谨慎使用,非必要别去设置超时时间,设置后性能会降低(因为需要把用户函数包装到另一个线单独的程中去运行),而且突然强制超时杀死运行中函数,可能会造成死锁.(例如用户函数在获得线程锁后突然杀死函数,别的线程再也无法获得锁了)
 
     log_level: int = logging.DEBUG  # 消费者和发布者的日志级别,建议设置DEBUG级别,不然无法知道正在运行什么消息
@@ -166,7 +167,7 @@ class BoosterParams(BaseJsonAbleModel):
     is_show_message_get_from_broker: bool = False  # 运行时候,是否记录从消息队列获取出来的消息内容
     is_print_detail_exception: bool = True  # 消费函数出错时候,是否打印详细的报错堆栈,为False则只打印简略的报错信息不包含堆栈.
 
-    msg_expire_senconds: typing.Union[float, int] = None  # 消息过期时间,可以设置消息是多久之前发布的就丢弃这条消息,不运行. 为None则永不丢弃
+    msg_expire_senconds: typing.Union[float, int,None] = None  # 消息过期时间,可以设置消息是多久之前发布的就丢弃这条消息,不运行. 为None则永不丢弃
 
     do_task_filtering: bool = False  # 是否对函数入参进行过滤去重.
     task_filtering_expire_seconds: int = 0  # 任务过滤的失效期，为0则永久性过滤任务。例如设置过滤过期时间是1800秒 ， 30分钟前发布过1 + 2 的任务，现在仍然执行，如果是30分钟以内执行过这个任务，则不执行1 + 2
@@ -174,7 +175,7 @@ class BoosterParams(BaseJsonAbleModel):
     function_result_status_persistance_conf: FunctionResultStatusPersistanceConfig = FunctionResultStatusPersistanceConfig(
         is_save_result=False, is_save_status=False, expire_seconds=7 * 24 * 3600, is_use_bulk_insert=False)  # 是否保存函数的入参，运行结果和运行状态到mongodb。这一步用于后续的参数追溯，任务统计和web展示，需要安装mongo。
 
-    user_custom_record_process_info_func: typing.Callable = None  # 提供一个用户自定义的保存消息处理记录到某个地方例如mysql数据库的函数，函数仅仅接受一个入参，入参类型是 FunctionResultStatus，用户可以打印参数
+    user_custom_record_process_info_func: typing.Optional[typing.Callable] = None  # 提供一个用户自定义的保存消息处理记录到某个地方例如mysql数据库的函数，函数仅仅接受一个入参，入参类型是 FunctionResultStatus，用户可以打印参数
 
     is_using_rpc_mode: bool = False  # 是否使用rpc模式，可以在发布端获取消费端的结果回调，但消耗一定性能，使用async_result.result时候会等待阻塞住当前线程。
     rpc_result_expire_seconds: int = 600  # 保存rpc结果的过期时间.
@@ -190,10 +191,11 @@ class BoosterParams(BaseJsonAbleModel):
 
     is_auto_start_consuming_message: bool = False  # 是否在定义后就自动启动消费，无需用户手动写 .consume() 来启动消息消费。
 
-    consuming_function: typing.Callable = None  # 消费函数,在@boost时候不用指定,因为装饰器知道下面的函数.
-    consuming_function_raw: typing.Callable = None
+    consuming_function: typing.Optional[typing.Callable] = None  # 消费函数,在@boost时候不用指定,因为装饰器知道下面的函数.
+    consuming_function_raw: typing.Optional[typing.Callable] = None  # 不需要传递，自动生成
+    consuming_function_name: str = '' # 不需要传递，自动生成
 
-    broker_kind: str = BrokerEnum.SQLITE_QUEUE  # 中间件选型见3.1章节 https://funboost.readthedocs.io/zh-cn/latest/articles/c3.html
+    
 
     broker_exclusive_config: dict = {}  # 加上一个不同种类中间件非通用的配置,不同中间件自身独有的配置，不是所有中间件都兼容的配置，因为框架支持30种消息队列，消息队列不仅仅是一般的先进先出queue这么简单的概念，
     # 例如kafka支持消费者组，rabbitmq也支持各种独特概念例如各种ack机制 复杂路由机制，有的中间件原生能支持消息优先级有的中间件不支持,每一种消息队列都有独特的配置参数意义，可以通过这里传递。每种中间件能传递的键值对可以看consumer类的 BROKER_EXCLUSIVE_CONFIG_DEFAULT
@@ -221,6 +223,7 @@ class BoosterParams(BaseJsonAbleModel):
 
     @root_validator(skip_on_failure=True)
     def check_values(cls, values: dict):
+       
 
         # 如果设置了qps，并且cocurrent_num是默认的50，会自动开了500并发，由于是采用的智能线程池任务少时候不会真开那么多线程而且会自动缩小线程数量。具体看ThreadPoolExecutorShrinkAble的说明
         # 由于有很好用的qps控制运行频率和智能扩大缩小的线程池，此框架建议不需要理会和设置并发数量只需要关心qps就行了，框架的并发是自适应并发数量，这一点很强很好用。
@@ -233,7 +236,8 @@ class BoosterParams(BaseJsonAbleModel):
 
         if values['concurrent_mode'] not in ConcurrentModeEnum.__dict__.values():
             raise ValueError('设置的并发模式不正确')
-        if values['broker_kind'] in [BrokerEnum.REDIS_ACK_ABLE, BrokerEnum.REDIS_STREAM, BrokerEnum.REDIS_PRIORITY, BrokerEnum.RedisBrpopLpush]:
+        if values['broker_kind'] in [BrokerEnum.REDIS_ACK_ABLE, BrokerEnum.REDIS_STREAM, BrokerEnum.REDIS_PRIORITY, 
+                                     BrokerEnum.RedisBrpopLpush,BrokerEnum.REDIS,BrokerEnum.REDIS_PUBSUB]:
             values['is_send_consumer_hearbeat_to_redis'] = True  # 需要心跳进程来辅助判断消息是否属于掉线或关闭的进程，需要重回队列
         # if not set(values.keys()).issubset(set(BoosterParams.__fields__.keys())):
         #     raise ValueError(f'{cls.__name__} 的字段包含了父类 BoosterParams 不存在的字段')
@@ -291,19 +295,28 @@ class PriorityConsumingControlConfig(BaseJsonAbleModel):
 
     function_timeout: typing.Union[float, int,None] = None
 
-    max_retry_times: int = None
+    max_retry_times: typing.Union[int,None] = None
 
-    is_print_detail_exception: bool = None
+    is_print_detail_exception: typing.Union[bool,None] = None
 
-    msg_expire_senconds: int = None
+    msg_expire_senconds: typing.Union[float, int,None] = None
 
-    is_using_rpc_mode: bool = None
+    is_using_rpc_mode: typing.Union[bool,None] = None
 
-    countdown: typing.Union[float, int] = None
-    eta: typing.Union[datetime.datetime, str] = None  # 时间对象， 或 %Y-%m-%d %H:%M:%S 字符串。
+    countdown: typing.Union[float, int,None] = None
+    eta: typing.Union[datetime.datetime, str,None] = None  # 时间对象， 或 %Y-%m-%d %H:%M:%S 字符串。
     misfire_grace_time: typing.Union[int, None] = None
 
     other_extra_params: dict = None  # 其他参数, 例如消息优先级 , priority_control_config=PriorityConsumingControlConfig(other_extra_params={'priroty': priorityxx})，
+    
+    """filter_str:
+    用户指定过滤字符串， 例如函数入参是 def fun(userid,username,sex，user_description),
+    默认是所有入参一起组成json来过滤，但其实只把userid的值来过滤就好了。所以如果需要精准的按照什么过滤，用户来灵活指定一个字符串就好了
+    
+    用法见文档4.35 
+    f3.publish(msg={'a':i,'b':i*2},priority_control_config=PriorityConsumingControlConfig(filter_str=str(i)))
+    """
+    filter_str :typing.Optional[str] = None 
 
     @root_validator(skip_on_failure=True)
     def cehck_values(cls, values: dict):
@@ -324,8 +337,8 @@ class PublisherParams(BaseJsonAbleModel):
     logger_name: str = ''  # 队列消费者发布者的日志命名空间.
     log_filename: typing.Optional[str] = None
     clear_queue_within_init: bool = False  # with 语法发布时候,先清空消息队列
-    consuming_function: typing.Callable = None  # consuming_function 作用是 inspect 模块获取函数的入参信息
-    broker_kind: str = None
+    consuming_function: typing.Optional[typing.Callable] = None  # consuming_function 作用是 inspect 模块获取函数的入参信息
+    broker_kind: typing.Optional[str] = None
     broker_exclusive_config: dict = {}
     should_check_publish_func_params: bool = True  # 消息发布时候是否校验消息发布内容,比如有的人发布消息,函数只接受a,b两个入参,他去传2个入参,或者传参不存在的参数名字,  如果消费函数你非要写*args,**kwargs,那就需要关掉发布消息时候的函数入参检查
     publisher_override_cls: typing.Optional[typing.Type] = None

funboost/core/loggers.py

@@ -53,3 +53,4 @@ if __name__ == '__main__':
     logger1 = get_funboost_file_logger('name1')
     logger1.info('啦啦啦啦啦啦啦')
     logger1.error('错错错')
+    

funboost/funboost_config_deafult.py

@@ -42,7 +42,7 @@ class BrokerConnConfig(DataClassBase):
     REDIS_USERNAME = ''
     REDIS_PASSWORD = ''
     REDIS_PORT = 6379
-    REDIS_DB = 7  # redis消息队列所在db，请不要在这个db放太多其他键值对，框架里面有的功能会scan扫描unacked的键名，使用单独的db。
+    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}'
 

funboost/function_result_web/app_debug_start.py

@@ -2,5 +2,5 @@ from funboost.function_result_web.app import app
 
 
 if __name__ == '__main__':
-    app.run(debug=True, threaded=True, host='0.0.0.0', port=27018)
+    app.run(debug=True, threaded=True, host='0.0.0.0', port=27019)
 

funboost/function_result_web/functions.py

@@ -167,7 +167,7 @@ def rpc_call(queue_name, msg_body, need_result, timeout):
             # if booster.boost_params.is_using_rpc_mode is False:
             #     raise ValueError(f' need_result 为true,{booster.queue_name} 队列消费者 需要@boost设置支持rpc模式')
             
-            async_result =  publisher.publish(msg_body,priority_control_config=PriorityConsumingControlConfig(is_using_rpc_mode=True))
+            async_result: AsyncResult =  publisher.publish(msg_body,priority_control_config=PriorityConsumingControlConfig(is_using_rpc_mode=True))
             async_result.set_timeout(timeout)
             status_and_result = async_result.status_and_result
             # print(status_and_result)
@@ -175,6 +175,9 @@ def rpc_call(queue_name, msg_body, need_result, timeout):
         else:
             async_result =publisher.publish(msg_body)
             task_id = async_result.task_id
+        if status_and_result['success'] is False:
+            return dict(succ=False, msg=f'{queue_name} 队列,消息发布成功,但是函数执行失败', 
+                            status_and_result=status_and_result,task_id=task_id)
         return dict(succ=True, msg=f'{queue_name} 队列,消息发布成功', 
                             status_and_result=status_and_result,task_id=task_id)
     except Exception as e:
@@ -186,6 +189,12 @@ def get_result_by_task_id(task_id,timeout):
     async_result = AsyncResult(task_id)
     async_result.set_timeout(timeout)
     status_and_result = async_result.status_and_result
+    if status_and_result is None:
+        return dict(succ=False, msg=f'{task_id} 不存在 或 超时 或 结果已过期', 
+                        status_and_result=status_and_result,task_id=task_id)
+    if status_and_result['success'] is False:
+        return dict(succ=False, msg=f'{task_id} 执行失败', 
+                        status_and_result=status_and_result,task_id=task_id)
     return dict(succ=True, msg=f'task_id:{task_id} 获取结果成功', 
                             status_and_result=status_and_result,task_id=task_id)
         

funboost/function_result_web/static/js/form-memory.js

@@ -0,0 +1,92 @@
+// 表单记忆功能 - 保存和恢复iframe内的表单值
+(function() {
+    // 简化版 - 只保存基本输入值
+    function saveFormInputs() {
+        const iframe = document.getElementById('content');
+        if (!iframe || !iframe.contentWindow) return;
+        
+        const pageId = iframe.src.split('/').pop().replace('.html', '');
+        
+        try {
+            const iframeDoc = iframe.contentDocument || iframe.contentWindow.document;
+            const formData = {};
+            
+            // 保存所有输入元素值
+            const inputs = iframeDoc.querySelectorAll('input, textarea, select');
+            inputs.forEach(input => {
+                const inputId = input.id || input.name || input.getAttribute('placeholder');
+                if (inputId) {
+                    formData[inputId] = input.value;
+                }
+            });
+            
+            // 特殊处理下拉框的选中文本
+            const selects = iframeDoc.querySelectorAll('select');
+            selects.forEach(select => {
+                const inputId = select.id || select.name;
+                if (inputId && select.selectedIndex >= 0 && select.options[select.selectedIndex]) {
+                    formData[`${inputId}_text`] = select.options[select.selectedIndex].text;
+                }
+            });
+            
+            localStorage.setItem(`funboost_form_${pageId}`, JSON.stringify(formData));
+        } catch (e) {
+            console.error("保存表单数据失败:", e);
+        }
+    }
+
+    // 简化版 - 只恢复基本输入值
+    function restoreFormInputs() {
+        setTimeout(() => {
+            const iframe = document.getElementById('content');
+            if (!iframe || !iframe.contentWindow) return;
+            
+            const pageId = iframe.src.split('/').pop().replace('.html', '');
+            const savedData = localStorage.getItem(`funboost_form_${pageId}`);
+            
+            if (savedData) {
+                try {
+                    const formData = JSON.parse(savedData);
+                    const iframeDoc = iframe.contentDocument || iframe.contentWindow.document;
+                    
+                    // 恢复所有基本输入元素的值
+                    Object.keys(formData).forEach(inputId => {
+                        if (inputId.endsWith('_text')) return;
+                        
+                        const input = iframeDoc.getElementById(inputId) || 
+                                  iframeDoc.querySelector(`[name="${inputId}"]`) || 
+                                  iframeDoc.querySelector(`[placeholder="${inputId}"]`);
+                        
+                        if (input) {
+                            input.value = formData[inputId];
+                            
+                            // 触发change事件
+                            const event = new Event('change', { bubbles: true });
+                            input.dispatchEvent(event);
+                        }
+                    });
+                } catch (e) {
+                    console.error("恢复表单数据失败:", e);
+                }
+            }
+        }, 500);
+    }
+
+    // 当DOM加载完成时初始化事件监听
+    document.addEventListener('DOMContentLoaded', function() {
+        // 监听iframe加载完成事件
+        const contentFrame = document.getElementById('content');
+        if (contentFrame) {
+            contentFrame.addEventListener('load', restoreFormInputs);
+        }
+
+        // 在页面切换前保存
+        const navLinks = document.querySelectorAll('.sidebar .nav-link');
+        navLinks.forEach(link => {
+            link.addEventListener('click', saveFormInputs);
+        });
+
+        // 页面离开前保存
+        window.addEventListener('beforeunload', saveFormInputs);
+    });
+})();