jettask 0.2.20__py3-none-any.whl → 0.2.24__py3-none-any.whl

jettask/core/app.py

@@ -26,7 +26,7 @@ from ..executor.orchestrator import ProcessOrchestrator
 from ..utils import gen_task_name
 from ..exceptions import TaskTimeoutError, TaskExecutionError, TaskNotFoundError
 # 导入统一的数据库连接管理
-from ..utils.db_connector import get_sync_redis_client, get_async_redis_client
+from jettask.db.connector import get_sync_redis_client, get_async_redis_client
 # 导入Lua脚本
 from ..config.lua_scripts import (
     LUA_SCRIPT_DELAYED_TASKS,
@@ -351,12 +351,15 @@ class Jettask(object):
         if self.task_center and self.task_center.is_enabled and not self._task_center_config:
             self._load_config_from_task_center()
 
-        # 使用超长超时时间，支持 Pub/Sub 长连接（可能几天没有消息）
+        # 使用无限超时，支持 Pub/Sub 长连接（可能几天没有消息）
+        import logging
+        logger = logging.getLogger(__name__)
+        logger.info(f"Creating async_redis client with socket_timeout=None for redis_url={self.redis_url}")
         return get_async_redis_client(
             redis_url=self.redis_url,
             decode_responses=True,
             max_connections=self.max_connections,
-            socket_timeout=99999999999  # 超长超时，几乎永不超时
+            socket_timeout=None  # 无限等待，不超时
         )
 
     @property
@@ -388,7 +391,7 @@ class Jettask(object):
             redis_url=self.redis_url,
             decode_responses=False,
             max_connections=self.max_connections,
-            socket_timeout=99999999999
+            socket_timeout=None
         )
 
     @property
@@ -456,11 +459,35 @@ class Jettask(object):
         
         return None
 
+    def get_task_config(self, task_name: str) -> dict:
+        """
+        获取任务配置
+
+        Args:
+            task_name: 任务名称
+
+        Returns:
+            任务配置字典，如果任务不存在则返回None
+        """
+        # 获取任务对象
+        task = self.get_task_by_name(task_name)
+        if not task:
+            return None
+
+        # 返回任务的配置（从Task对象的属性中提取）
+        return {
+            'auto_ack': getattr(task, 'auto_ack', True),
+            'queue': getattr(task, 'queue', None),
+            'timeout': getattr(task, 'timeout', None),
+            'max_retries': getattr(task, 'max_retries', 0),
+            'retry_delay': getattr(task, 'retry_delay', None),
+        }
+
     def include_module(self, modules: list):
         self.include += modules
 
     def _task_from_fun(
-        self, fun, name=None, base=None, queue=None, bind=False, retry_config=None, rate_limit=None, **options
+        self, fun, name=None, base=None, queue=None, bind=False, retry_config=None, rate_limit=None, auto_ack=True, **options
     ) -> Task:
         name = name or gen_task_name(fun.__name__, fun.__module__)
         base = base or Task
@@ -480,6 +507,7 @@ class Jettask(object):
                         "queue": queue,
                         "retry_config": retry_config,  # 存储重试配置
                         "rate_limit": rate_limit,  # 存储限流配置
+                        "auto_ack": auto_ack,  # 存储自动ACK配置
                         "_decorated": True,
                         "__doc__": fun.__doc__,
                         "__module__": fun.__module__,
@@ -566,9 +594,25 @@ class Jettask(object):
         retry_on_exceptions: tuple = None,  # 可重试的异常类型
         # 限流相关参数
         rate_limit: int = None,  # QPS 限制（每秒允许执行的任务数）
+        # ACK相关参数
+        auto_ack: bool = True,  # 是否自动ACK（默认True）
         *args,
         **kwargs,
     ):
+        """
+        任务装饰器 - 统一使用 TaskRouter 内部实现
+
+        Args:
+            name: 任务名称
+            queue: 队列名称
+            base: 基类
+            max_retries: 最大重试次数
+            retry_backoff: 是否使用指数退避
+            retry_backoff_max: 最大退避时间
+            retry_on_exceptions: 可重试的异常类型
+            rate_limit: 限流配置（QPS或RateLimitConfig对象）
+            auto_ack: 是否自动ACK（默认True）
+        """
         def _create_task_cls(fun):
             # 将重试配置传递给_task_from_fun
             retry_config = None
@@ -584,7 +628,19 @@ class Jettask(object):
                         exc if isinstance(exc, str) else exc.__name__
                         for exc in retry_on_exceptions
                     ]
-            return self._task_from_fun(fun, name, base, queue, retry_config=retry_config, rate_limit=rate_limit, *args, **kwargs)
+
+            # 统一通过 _task_from_fun 创建任务，包含 auto_ack 参数
+            return self._task_from_fun(
+                fun,
+                name,
+                base,
+                queue,
+                retry_config=retry_config,
+                rate_limit=rate_limit,
+                auto_ack=auto_ack,  # 传递 auto_ack
+                *args,
+                **kwargs
+            )
 
         return _create_task_cls
     
@@ -681,6 +737,92 @@ class Jettask(object):
         else:
             return self._send_tasks_sync(messages)
 
+    def ack(self, ack_items: list):
+        """
+        批量确认消息（ACK）
+
+        用于 auto_ack=False 的任务，手动批量确认消息。
+        这是同步方法，会在后台异步执行ACK操作。
+
+        Args:
+            ack_items: ACK项列表，每项可以是：
+                - (queue, event_id): 简单形式
+                - (queue, event_id, group_name): 带消费者组名
+                - (queue, event_id, group_name, offset): 完整形式
+                - dict: {'queue': ..., 'event_id': ..., 'group_name': ..., 'offset': ...}
+
+        Example:
+            from jettask import TaskRouter
+
+            router = TaskRouter()
+
+            @router.task(queue="batch_queue", auto_ack=False)
+            async def process_batch(ctx, items):
+                # 批量处理
+                results = []
+                ack_list = []
+
+                for item in items:
+                    try:
+                        result = await process_item(item)
+                        results.append(result)
+
+                        # 收集需要ACK的消息
+                        ack_list.append((
+                            ctx.queue,
+                            item['event_id'],
+                            ctx.group_name,
+                            item.get('offset')
+                        ))
+                    except Exception as e:
+                        logger.error(f"Failed to process {item}: {e}")
+
+                # 批量确认成功处理的消息
+                ctx.app.ack(ack_list)
+
+                return results
+        """
+        if not ack_items:
+            return
+
+        # 检查是否有 executor_core（Worker运行时才有）
+        if not hasattr(self, '_executor_core') or not self._executor_core:
+            logger.warning("ACK can only be called in worker context")
+            return
+
+        # 将ACK项添加到executor_core的pending_acks
+        for item in ack_items:
+            if isinstance(item, dict):
+                queue = item['queue']
+                event_id = item['event_id']
+                group_name = item.get('group_name')
+                offset = item.get('offset')
+            elif isinstance(item, (tuple, list)):
+                if len(item) >= 2:
+                    queue, event_id = item[0], item[1]
+                    group_name = item[2] if len(item) > 2 else None
+                    offset = item[3] if len(item) > 3 else None
+                else:
+                    logger.error(f"Invalid ACK item format: {item}")
+                    continue
+            else:
+                logger.error(f"Invalid ACK item type: {type(item)}")
+                continue
+
+            # 添加到pending_acks
+            self._executor_core.pending_acks.append((queue, event_id, group_name or queue, offset))
+
+        # 检查是否需要立即刷新
+        if len(self._executor_core.pending_acks) >= 100:
+            # 创建异步任务刷新
+            import asyncio
+            try:
+                loop = asyncio.get_running_loop()
+                asyncio.create_task(self._executor_core._flush_all_buffers())
+            except RuntimeError:
+                # 不在事件循环中，稍后会自动刷新
+                pass
+
     def _send_tasks_sync(self, messages: list):
         """同步发送任务"""
         if not messages:
@@ -1860,10 +2002,17 @@ class Jettask(object):
         self._mount_module()
 
         # 收集任务列表（按队列分组）
+        # 需要处理通配符队列的情况：如果 task.queue 是通配符（如 'robust_*'），
+        # 则保持通配符作为键，后续动态发现时会通过通配符匹配找到对应任务
+        from jettask.utils.queue_matcher import match_task_queue_to_patterns
+
         self._tasks_by_queue = {}
         for task_name, task in self._tasks.items():
             task_queue = task.queue or self.redis_prefix
-            if task_queue in queues:
+
+            # 检查 task_queue 是否匹配 queues 中的任何一个（支持通配符）
+            if match_task_queue_to_patterns(task_queue, queues):
+                # 使用 task_queue（可能是通配符）作为键
                 if task_queue not in self._tasks_by_queue:
                     self._tasks_by_queue[task_queue] = []
                 self._tasks_by_queue[task_queue].append(task_name)
@@ -2045,14 +2194,14 @@ class Jettask(object):
                 logger.debug("Closing async Redis connections...")
 
                 # 关闭 EventPool 的连接
-                if hasattr(self.ep, 'async_redis_client'):
+                if hasattr(self.ep, 'async_redis_client') and self.ep.async_redis_client:
                     await self.ep.async_redis_client.aclose()
 
-                if hasattr(self.ep, 'async_binary_redis_client'):
+                if hasattr(self.ep, 'async_binary_redis_client') and self.ep.async_binary_redis_client:
                     await self.ep.async_binary_redis_client.aclose()
 
                 # 关闭 app 级别的连接
-                if hasattr(self, '_async_redis'):
+                if hasattr(self, '_async_redis') and self._async_redis:
                     await self._async_redis.aclose()
 
                 logger.debug("Async Redis connections closed")
@@ -2062,10 +2211,19 @@ class Jettask(object):
         # 在新的事件循环中执行异步清理
         try:
             import asyncio
-            cleanup_loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(cleanup_loop)
-            cleanup_loop.run_until_complete(async_cleanup_redis())
-            cleanup_loop.close()
+            # 检查是否已有运行中的事件循环
+            try:
+                loop = asyncio.get_running_loop()
+                # 如果已有运行中的循环，直接创建 task
+                asyncio.create_task(async_cleanup_redis())
+            except RuntimeError:
+                # 没有运行中的循环，创建新的
+                cleanup_loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(cleanup_loop)
+                try:
+                    cleanup_loop.run_until_complete(async_cleanup_redis())
+                finally:
+                    cleanup_loop.close()
         except Exception as e:
             logger.error(f"Error in Redis cleanup: {e}", exc_info=True)
 
@@ -2263,7 +2421,7 @@ class Jettask(object):
                 )
             
             from ..scheduler import TaskScheduler
-            from ..scheduler.task_crud import ScheduledTaskManager
+            from ..scheduler.database import ScheduledTaskManager
             
             # 创建数据库管理器
             self.scheduler_manager = ScheduledTaskManager(db_url)
@@ -2281,8 +2439,9 @@ class Jettask(object):
                 db_manager=self.scheduler_manager,
                 **scheduler_config
             )
-            
-            await self.scheduler.connect()
+
+            # 初始化数据库管理器连接
+            await self.scheduler_manager.connect()
             logger.debug("Scheduler initialized")
     
     async def start_scheduler(self):
@@ -2301,352 +2460,166 @@ class Jettask(object):
         if self.scheduler:
             self.scheduler.stop()
             logger.debug("Scheduler stopped")
-    
-    async def add_scheduled_task(
-        self,
-        task_name: str,
-        scheduler_id: str,  # 必填参数
-        queue_name: str = None,
-        task_type: str = "interval",
-        interval_seconds: float = None,
-        cron_expression: str = None,
-        task_args: list = None,
-        task_kwargs: dict = None,
-        next_run_time: datetime = None,
-        skip_if_exists: bool = True,
-        at_once: bool = True,  # 是否立即保存到数据库
-        **extra_params
-    ):
+
+    async def register_schedules(self, schedules):
         """
-        添加定时任务
-        
+        注册定时任务（支持单个或批量）
+
+        这是新的统一注册方法，类似 TaskMessage 的设计模式。
+
         Args:
-            task_name: 要执行的函数名（必须对应已经通过@app.task注册的任务）
-            scheduler_id: 任务的唯一标识符（必填，用于去重）
-            queue_name: 目标队列名（可选，从task_name对应的任务自动获取）
-            task_type: 任务类型 ('once', 'interval', 'cron')
-            interval_seconds: 间隔秒数 (task_type='interval'时使用)
-            cron_expression: Cron表达式 (task_type='cron'时使用)
-            task_args: 任务参数列表
-            task_kwargs: 任务关键字参数
-            next_run_time: 首次执行时间 (task_type='once'时使用)
-            skip_if_exists: 如果任务已存在是否跳过（默认True）
-            at_once: 是否立即保存到数据库（默认True），如果False则返回任务对象用于批量写入
-            **extra_params: 其他参数 (如 max_retries, timeout, description 等)
+            schedules: ScheduledMessage 对象或列表
+
+        Returns:
+            注册的任务数量
+
+        Example:
+            from jettask import Schedule
+
+            # 1. 定义定时任务
+            schedule1 = Schedule(
+                scheduler_id="notify_every_30s",
+                queue="notification_queue",
+                interval_seconds=30,
+                kwargs={"user_id": "user_123", "message": "定时提醒"}
+            )
+
+            schedule2 = Schedule(
+                scheduler_id="report_cron",
+                queue="report_queue",
+                cron_expression="0 9 * * *",
+                description="每天生成报告"
+            )
+
+            # 2. 批量注册
+            count = await app.register_schedules([schedule1, schedule2])
+            print(f"注册了 {count} 个定时任务")
         """
+        from ..scheduler.schedule import Schedule
+        from ..scheduler.models import ScheduledTask, TaskType
+
         # 自动初始化
         await self._ensure_scheduler_initialized()
-        
-        from ..scheduler.models import ScheduledTask, TaskType
-        
-        # 尝试从已注册的任务中获取信息
-        registered_task = None
-        
-        # 1. 直接匹配
-        registered_task = self._tasks.get(task_name)
-        
-        # 2. 如果没找到，尝试查找以task_name结尾的任务（如 "module.task_name"）
-        if not registered_task:
-            for task_key, task_obj in self._tasks.items():
-                if task_key.endswith(f".{task_name}") or task_key == task_name:
-                    registered_task = task_obj
-                    break
-        
-        if not registered_task:
-            # 任务必须已注册
-            available_tasks = list(self._tasks.keys())
-            error_msg = f"Task '{task_name}' not found in registered tasks.\n"
-            error_msg += "All scheduled tasks must be registered with @app.task decorator.\n"
-            if available_tasks:
-                error_msg += f"Available tasks: {', '.join(available_tasks)}"
-            raise ValueError(error_msg)
-        
-        # 自动填充信息
-        if not queue_name:
-            queue_name = registered_task.queue or self.redis_prefix
-        
-        # 使用注册时的完整任务名称（包含模块前缀）
-        # 查找任务的完整注册名称
-        full_task_name = None
-        for task_key, task_obj in self._tasks.items():
-            if task_obj == registered_task:
-                full_task_name = task_key
-                break
-        
-        if not full_task_name:
-            # 如果没找到，使用用户提供的名称
-            full_task_name = task_name
-        
-        # 处理 next_run_time（主要用于 once 类型）
-        if task_type == "once" and extra_params.get("next_run_time"):
-            # 如果在 extra_params 中，移到正确位置
-            next_run_time = extra_params.pop("next_run_time", None)
-        
-        # 移除不属于ScheduledTask的参数
-        extra_params.pop("skip_if_exists", None)
-        
-        # scheduler_id是必填参数，必须由用户提供
-        if not scheduler_id:
-            raise ValueError("scheduler_id is required and must be provided")
-        
+
+        # 支持单个或列表
+        if isinstance(schedules, Schedule):
+            schedules = [schedules]
+
+        if not schedules:
+            return 0
+
         # 获取当前命名空间
         namespace = 'default'
         if self.task_center and hasattr(self.task_center, 'namespace_name'):
             namespace = self.task_center.namespace_name
         elif self.redis_prefix and self.redis_prefix != 'jettask':
-            # 如果没有task_center，使用redis_prefix作为命名空间
             namespace = self.redis_prefix
-        
-        # 创建任务对象
-        task = ScheduledTask(
-            scheduler_id=scheduler_id,
-            task_name=full_task_name,  # 使用完整的任务名称（包含模块前缀）
-            task_type=TaskType(task_type),
-            queue_name=queue_name,
-            namespace=namespace,  # 设置命名空间
-            task_args=task_args or [],
-            task_kwargs=task_kwargs or {},
-            interval_seconds=interval_seconds,
-            cron_expression=cron_expression,
-            next_run_time=next_run_time,
-            **extra_params
-        )
-        
-        # 如果不立即保存，返回任务对象供批量写入
-        if not at_once:
-            # 设置skip_if_exists标记供批量写入时使用
-            task._skip_if_exists = skip_if_exists
-            return task
-        
-        # 保存到数据库（支持去重）
-        task, created = await self.scheduler_manager.create_or_get_task(task, skip_if_exists=skip_if_exists)
-        
-        if created:
-            logger.debug(f"Scheduled task {task.id} created for function {task_name}")
-        else:
-            logger.debug(f"Scheduled task {task.id} already exists for function {task_name}")
-        
-        return task
-    
-    async def remove_scheduled_task(self, scheduler_id: str):
-        """移除定时任务"""
-        # 自动初始化
+
+        # 转换为 ScheduledTask 对象
+        tasks = []
+        for schedule in schedules:
+            if not isinstance(schedule, Schedule):
+                raise ValueError(f"Expected Schedule, got {type(schedule)}")
+
+            data = schedule.to_dict()
+            task = ScheduledTask(
+                scheduler_id=data['scheduler_id'],
+                task_type=TaskType(data['task_type']),
+                queue_name=data['queue'],
+                namespace=namespace,
+                task_args=data['task_args'],
+                task_kwargs=data['task_kwargs'],
+                interval_seconds=data.get('interval_seconds'),
+                cron_expression=data.get('cron_expression'),
+                next_run_time=data.get('next_run_time'),
+                enabled=data['enabled'],
+                priority=data['priority'],
+                timeout=data['timeout'],
+                max_retries=data['max_retries'],
+                retry_delay=data['retry_delay'],
+                description=data['description'],
+                tags=data['tags'],
+                metadata=data['metadata']
+            )
+            # 保存 skip_if_exists 选项
+            task._skip_if_exists = schedule.skip_if_exists
+            tasks.append(task)
+
+        # 批量注册到数据库
+        registered_count = 0
+        for task in tasks:
+            skip_if_exists = getattr(task, '_skip_if_exists', True)
+            _, created = await self.scheduler_manager.create_or_get_task(task, skip_if_exists=skip_if_exists)
+            if created:
+                registered_count += 1
+                logger.info(f"已注册定时任务: {task.scheduler_id} -> {task.queue_name}")
+            else:
+                logger.debug(f"定时任务已存在: {task.scheduler_id}")
+
+        return registered_count
+
+    async def list_schedules(self, **filters):
+        """
+        列出定时任务
+
+        Args:
+            **filters: 过滤条件（enabled, queue_name, task_type 等）
+
+        Returns:
+            List[ScheduledTask]: 任务列表
+        """
+        await self._ensure_scheduler_initialized()
+        return await self.scheduler_manager.list_tasks(**filters)
+
+    async def remove_schedule(self, scheduler_id: str) -> bool:
+        """
+        移除定时任务
+
+        Args:
+            scheduler_id: 任务唯一标识符
+
+        Returns:
+            bool: 是否成功移除
+        """
         await self._ensure_scheduler_initialized()
-        
-        # 先获取任务
         task = await self.scheduler_manager.get_task_by_scheduler_id(scheduler_id)
         if not task:
             return False
-        
-        success = await self.scheduler_manager.delete_task(task.id)
-        
-        if success and self.scheduler:
-            # 从Redis中也移除
-            await self.scheduler.loader.remove_task(task.id)
-        
-        return success
-    
-    async def batch_add_scheduled_tasks(
-        self,
-        tasks: list,
-        skip_existing: bool = True
-    ):
+        return await self.scheduler_manager.delete_task(task.id)
+
+    async def pause_schedule(self, scheduler_id: str) -> bool:
         """
-        批量添加定时任务
-        
+        暂停定时任务
+
         Args:
-            tasks: 任务配置列表，每个元素是一个字典，包含add_scheduled_task的参数
-            skip_existing: 是否跳过已存在的任务
-            
+            scheduler_id: 任务唯一标识符
+
         Returns:
-            成功创建的任务列表
+            bool: 是否成功暂停
         """
-        # 自动初始化
         await self._ensure_scheduler_initialized()
-        
-        from ..scheduler.models import ScheduledTask, TaskType
-        
-        task_objects = []
-        for task_config in tasks:
-            # 获取任务名称
-            task_name = task_config.get('task_name')
-            if not task_name:
-                logger.warning("Task config missing task_name, skipping")
-                continue
-            
-            # 查找注册的任务
-            registered_task = self._tasks.get(task_name)
-            if not registered_task:
-                for task_key, task_obj in self._tasks.items():
-                    if task_key.endswith(f".{task_name}") or task_key == task_name:
-                        registered_task = task_obj
-                        task_name = task_key  # 使用完整名称
-                        break
-            
-            if not registered_task:
-                logger.warning(f"Task '{task_name}' not found in registered tasks, skipping")
-                continue
-            
-            # 准备任务参数
-            queue_name = task_config.get('queue_name') or registered_task.queue or self.redis_prefix
-            task_type = task_config.get('task_type', 'interval')
-            
-            # 处理next_run_time
-            next_run_time = task_config.get('next_run_time')
-            if task_type == 'once' and not next_run_time:
-                next_run_time = datetime.now()
-            
-            # scheduler_id是必填参数
-            scheduler_id = task_config.get('scheduler_id')
-            if not scheduler_id:
-                raise ValueError(f"Task config for '{task_name}' missing required scheduler_id")
-            
-            # 获取当前命名空间
-            namespace = 'default'
-            if self.task_center and hasattr(self.task_center, 'namespace_name'):
-                namespace = self.task_center.namespace_name
-            elif self.redis_prefix and self.redis_prefix != 'jettask':
-                # 如果没有task_center，使用redis_prefix作为命名空间
-                namespace = self.redis_prefix
-            
-            # 创建任务对象
-            task_obj = ScheduledTask(
-                scheduler_id=scheduler_id,
-                task_name=task_name,
-                task_type=TaskType(task_type),
-                queue_name=queue_name,
-                namespace=namespace,  # 设置命名空间
-                task_args=task_config.get('task_args', []),
-                task_kwargs=task_config.get('task_kwargs', {}),
-                interval_seconds=task_config.get('interval_seconds'),
-                cron_expression=task_config.get('cron_expression'),
-                next_run_time=next_run_time,
-                enabled=task_config.get('enabled', True),
-                max_retries=task_config.get('max_retries', 3),
-                retry_delay=task_config.get('retry_delay', 60),
-                timeout=task_config.get('timeout', 300),
-                description=task_config.get('description'),
-                tags=task_config.get('tags', []),
-                metadata=task_config.get('metadata', {})
-            )
-            task_objects.append(task_obj)
-        
-        # 批量创建
-        created_tasks = await self.scheduler_manager.batch_create_tasks(task_objects, skip_existing)
-        
-        logger.debug(f"Batch created {len(created_tasks)} scheduled tasks")
-        return created_tasks
-    
-    async def bulk_write_scheduled_tasks(self, tasks: list):
+        task = await self.scheduler_manager.get_task_by_scheduler_id(scheduler_id)
+        if not task:
+            return False
+        task.enabled = False
+        await self.scheduler_manager.update_task(task)
+        return True
+
+    async def resume_schedule(self, scheduler_id: str) -> bool:
         """
-        批量写入定时任务（配合at_once=False使用）
-        
-        使用示例：
-            # 收集任务对象
-            tasks = []
-            for i in range(100):
-                task = await app.add_scheduled_task(
-                    task_name="my_task",
-                    scheduler_id=f"task_{i}",
-                    task_type="interval",
-                    interval_seconds=30,
-                    at_once=False  # 不立即保存
-                )
-                tasks.append(task)
-            
-            # 批量写入
-            created_tasks = await app.bulk_write_scheduled_tasks(tasks)
-        
+        恢复定时任务
+
         Args:
-            tasks: 通过add_scheduled_task(at_once=False)创建的任务对象列表
-        
+            scheduler_id: 任务唯一标识符
+
         Returns:
-            成功创建的任务列表
+            bool: 是否成功恢复
         """
-        # 自动初始化
-        await self._ensure_scheduler_initialized()
-        
-        if not tasks:
-            return []
-        
-        # 准备批量创建的任务列表
-        task_objects = []
-        for task in tasks:
-            if not hasattr(task, 'scheduler_id'):
-                logger.warning("Invalid task object, skipping")
-                continue
-            
-            
-            task_objects.append(task)
-        
-        # 批量创建（使用第一个任务的skip_if_exists设置）
-        skip_existing = getattr(tasks[0], '_skip_if_exists', True) if tasks else True
-        created_tasks = await self.scheduler_manager.batch_create_tasks(task_objects, skip_existing)
-        
-        logger.debug(f"Bulk wrote {len(created_tasks)} scheduled tasks")
-        return created_tasks
-    
-    async def list_scheduled_tasks(self, **filters):
-        """列出定时任务"""
-        # 自动初始化
-        await self._ensure_scheduler_initialized()
-        
-        return await self.scheduler_manager.list_tasks(**filters)
-    
-    async def get_scheduled_task(self, scheduler_id: str):
-        """获取定时任务详情"""
-        # 自动初始化
         await self._ensure_scheduler_initialized()
-        
-        return await self.scheduler_manager.get_task_by_scheduler_id(scheduler_id)
-    
-    async def pause_scheduled_task(self, scheduler_id: str):
-        """暂停/禁用定时任务"""
-        # 自动初始化
-        await self._ensure_scheduler_initialized()
-        
-        # 通过scheduler_id获取任务
         task = await self.scheduler_manager.get_task_by_scheduler_id(scheduler_id)
-            
-        if task:
-            task.enabled = False
-            await self.scheduler_manager.update_task(task)
-            
-            # 从Redis中移除
-            if self.scheduler:
-                await self.scheduler.loader.remove_task(task.id)
-            
-            logger.debug(f"Task {task.id} (scheduler_id: {task.scheduler_id}) disabled")
-            return True
-        return False
-    
-    async def resume_scheduled_task(self, scheduler_id: str):
-        """恢复/启用定时任务"""
-        # 自动初始化
-        await self._ensure_scheduler_initialized()
-        
-        # 通过scheduler_id获取任务
-        task = await self.scheduler_manager.get_task_by_scheduler_id(scheduler_id)
-            
-        if task:
-            task.enabled = True
-            task.next_run_time = task.calculate_next_run_time()
-            await self.scheduler_manager.update_task(task)
-            
-            # 触发重新加载
-            if self.scheduler:
-                await self.scheduler.loader.load_tasks()
-            
-            logger.debug(f"Task {task.id} (scheduler_id: {task.scheduler_id}) enabled")
-            return True
-        return False
-    
-    # 别名，更直观
-    async def disable_scheduled_task(self, scheduler_id: str):
-        """禁用定时任务"""
-        return await self.pause_scheduled_task(scheduler_id=scheduler_id)
-    
-    async def enable_scheduled_task(self, scheduler_id: str):
-        """启用定时任务"""
-        return await self.resume_scheduled_task(scheduler_id=scheduler_id)
-    
+        if not task:
+            return False
+        task.enabled = True
+        await self.scheduler_manager.update_task(task)
+        return True
+