pip install myboot

# 显示帮助信息
myboot --help

# 初始化新项目（交互式）
myboot init

# 使用指定模板初始化项目
myboot init --name my-app --template basic    # 基础模板
myboot init --name my-app --template api      # API 项目模板
myboot init --name my-app --template full     # 完整项目模板

# 显示框架信息
myboot info

"""main.py - 应用入口文件"""
from myboot.core.application import create_app

# 创建应用实例
app = create_app(name="我的应用")

# 运行应用
if __name__ == "__main__":
    app.run()

"""app/api/routes.py"""
from myboot.core.decorators import rest_controller, get, post

@rest_controller('/api')
class HelloController:
    """Hello 控制器"""

    @get('/')
    def hello(self):
        """Hello World 接口 - GET /api"""
        return {"message": "Hello, MyBoot!", "status": "success"}

@rest_controller('/api/users')
class UserController:
    """用户控制器 - 支持依赖注入"""

    def __init__(self, user_service: UserService):
        self.user_service = user_service

    @get('/{user_id}')
    def get_user(self, user_id: int):
        """获取用户 - GET /api/users/{user_id}"""
        return self.user_service.get_user(user_id)

# 直接运行
python main.py

# 启用自动重载（开发环境）
python main.py --reload

# 指定端口和主机
python main.py --host 0.0.0.0 --port 8080

from myboot.core.decorators import service, rest_controller, get, cron, component

@service()
class UserService:
    """用户服务 - 自动注册为 'user_service'"""
    def get_user(self, user_id):
        return {"id": user_id, "name": f"用户{user_id}"}

@rest_controller('/api/users')
class UserController:
    """用户控制器 - 支持依赖注入"""

    def __init__(self, user_service: UserService):
        self.user_service = user_service

    @get('/{user_id}')
    def get_user(self, user_id: int):
        """获取用户 - GET /api/users/{user_id}"""
        return self.user_service.get_user(user_id)

@component()
class ScheduledJobs:
    """定时任务组件 - 使用 @component 装饰器定义定时任务"""

    @cron('0 */5 * * * *')
    def cleanup_task(self):
        """清理任务 - 自动注册定时任务"""
        print("执行清理任务")

from myboot.core.application import Application

# 创建应用，自动发现和配置所有组件
app = Application(
    name="我的应用",
    auto_configuration=True,  # 启用自动配置
    auto_discover_package="app"  # 自动发现 app 包
)

# 直接运行，无需手动注册
app.run()

from myboot.core.decorators import service

@service()
class UserService:
    def __init__(self):
        self.users = {}

@service()
class EmailService:
    def send_email(self, to: str, subject: str):
        print(f"发送邮件到 {to}: {subject}")

@service()
class OrderService:
    # 自动注入 UserService 和 EmailService
    def __init__(self, user_service: UserService, email_service: EmailService):
        self.user_service = user_service
        self.email_service = email_service

    def create_order(self, user_id: int):
        user = self.user_service.get_user(user_id)
        self.email_service.send_email(user['email'], "订单创建", "您的订单已创建")

from myboot.core.decorators import rest_controller, get, service

@service()
class UserService:
    def get_user(self, user_id: int):
        return {"user_id": user_id}

@rest_controller('/api/users')
class UserController:
    def __init__(self, user_service: UserService):
        # 通过构造函数自动注入服务
        self.user_service = user_service

    @get('/{user_id}')
    def get_user(self, user_id: int):
        return self.user_service.get_user(user_id)

from myboot.core.application import get_service

# 在启动钩子或其他地方获取服务
def some_function():
    user_service = get_service('user_service')
    return user_service.get_user(1)

from myboot.core.decorators import rest_controller, get, client

@client()
class RedisClient:
    def get(self, key: str):
        return None

@rest_controller('/api/products')
class ProductController:
    def __init__(self, redis_client: RedisClient):
        # 通过构造函数自动注入客户端
        self.redis_client = redis_client

    @get('/')
    def get_products(self):
        cache_data = self.redis_client.get('products')
        return {"products": cache_data or []}

from myboot.core.application import get_client

# 在启动钩子或其他地方获取客户端
def some_function():
    redis_client = get_client('redis_client')
    return redis_client.get('products')

from myboot.core.decorators import service, client, rest_controller, get, post

# 定义服务
@service()
class UserService:
    """用户服务 - 自动注册为 'user_service'"""
    def get_user(self, user_id: int):
        return {"id": user_id, "name": f"用户{user_id}"}

    def create_user(self, name: str, email: str):
        return {"name": name, "email": email}

@service()
class EmailService:
    """邮件服务"""
    def send_email(self, to: str, subject: str, body: str):
        print(f"发送邮件到 {to}")

# 定义客户端
@client('redis_client')
class RedisClient:
    """Redis 客户端 - 注册为 'redis_client'"""
    def get(self, key: str):
        return None

# 控制器中使用依赖注入
@rest_controller('/api/users')
class UserController:
    """用户控制器 - 自动注入服务和客户端"""

    def __init__(self, user_service: UserService, email_service: EmailService, redis_client: RedisClient):
        self.user_service = user_service
        self.email_service = email_service
        self.redis_client = redis_client

    @get('/{user_id}')
    def get_user(self, user_id: int):
        """获取用户"""
        # 先检查缓存
        cache_key = f"user:{user_id}"
        cached = self.redis_client.get(cache_key)
        if cached:
            return cached
        return self.user_service.get_user(user_id)

    @post('/')
    def create_user(self, name: str, email: str):
        """创建用户"""
        user = self.user_service.create_user(name, email)
        self.email_service.send_email(email, "欢迎", f"欢迎 {name}")
        return {"message": "用户创建成功", "user": user}

from myboot.core.application import Application

# 创建应用
app = Application(name="我的应用")

# 开发环境（单进程 + 自动重载）
app.run(host="0.0.0.0", port=8000, reload=True, workers=1)

# 生产环境（多进程）
app.run(host="0.0.0.0", port=8000, workers=4)

# 或者直接运行 main.py
# python main.py --reload  # 开发环境
# python main.py --workers 4  # 生产环境

from myboot.core.config import get_settings, get_config

# 直接使用 Dynaconf settings（自动查找配置文件）
settings = get_settings()
app_name = settings.app.name
server_port = settings.server.port

# 使用便捷函数
database_url = get_config('database.url', 'sqlite:///./app.db')
debug_mode = get_config('app.debug', False)

# 指定配置文件路径
settings = get_settings('custom_config.yaml')

# 通过环境变量指定配置文件
# export CONFIG_FILE=/path/to/config.yaml
# 或
# export CONFIG_FILE=https://example.com/config.yaml

# 使用环境变量覆盖配置值
export APP__NAME="MyApp"
export SERVER__PORT=9000
export LOGGING__LEVEL=DEBUG

# 嵌套配置使用双下划线分隔
export SERVER__CORS__ALLOW_ORIGINS='["http://localhost:3000"]'

from myboot.core.config import get_settings

# 从远程 URL 加载配置
settings = get_settings('https://example.com/config.yaml')

export APP__NAME="MyApp"
export SERVER__PORT=9000
export LOGGING__LEVEL=DEBUG

docker build -t my-app .
docker run -p 8000:8000 my-app

# 或用 compose
docker compose up --build

docker run -p 8080:8080 -e SERVER__PORT=8080 -e LOGGING__LEVEL=DEBUG my-app

from myboot.core.decorators import rest_controller, get, post, put, delete, service
from myboot.web.models import BaseResponse


@service()
class UserService:
    """用户服务"""
    def get_users(self):
        return []

    def get_user(self, user_id: int):
        return {"user_id": user_id, "name": f"用户{user_id}"}

    def create_user(self, name: str, email: str):
        return {"name": name, "email": email}

    def update_user(self, user_id: int, **kwargs):
        return {"user_id": user_id, **kwargs}

    def delete_user(self, user_id: int):
        return {"user_id": user_id}


@rest_controller('/api/users')
class UserController:
    """用户控制器 - 自动注入 UserService"""

    def __init__(self, user_service: UserService):
        self.user_service = user_service

    @get('/')
    def get_users(self):
        """获取用户列表 - GET /api/users"""
        users = self.user_service.get_users()
        return BaseResponse(success=True, message="获取用户列表成功", data={"users": users})

    @get('/{user_id}')
    def get_user(self, user_id: int):
        """获取单个用户 - GET /api/users/{user_id}"""
        user = self.user_service.get_user(user_id)
        return BaseResponse(success=True, message="获取用户成功", data=user)

    @post('/')
    def create_user(self, name: str, email: str):
        """创建用户 - POST /api/users"""
        user = self.user_service.create_user(name, email)
        return BaseResponse(success=True, message="用户创建成功", data=user)

    @put('/{user_id}')
    def update_user(self, user_id: int, name: str = None, email: str = None):
        """更新用户 - PUT /api/users/{user_id}"""
        update_data = {}
        if name:
            update_data['name'] = name
        if email:
            update_data['email'] = email
        user = self.user_service.update_user(user_id, **update_data)
        return BaseResponse(success=True, message=f"用户 {user_id} 更新成功", data=user)

    @delete('/{user_id}')
    def delete_user(self, user_id: int):
        """删除用户 - DELETE /api/users/{user_id}"""
        user = self.user_service.delete_user(user_id)
        return BaseResponse(success=True, message=f"用户 {user_id} 删除成功", data=user)


# 约定优于配置说明：
# 1. 使用 @rest_controller 装饰器定义控制器类和基础路径
# 2. 使用 @get, @post, @put, @delete 装饰器定义路由方法
# 3. 构造函数参数自动进行依赖注入
# 4. 框架自动发现和注册控制器
# 5. 统一的响应格式和错误处理

from myboot.core.decorators import rest_controller, get, post, put, delete
from myboot.web.models import BaseResponse

@rest_controller('/api/users')
class UserController:
    """用户控制器"""

    def __init__(self):
        # 可以在这里初始化服务、客户端等
        pass

    @get('/')
    def list_users(self):
        """获取用户列表 - GET /api/users"""
        return BaseResponse(
            success=True,
            message="获取用户列表成功",
            data={"users": []}
        )

    @get('/{user_id}')
    def get_user(self, user_id: int):
        """获取单个用户 - GET /api/users/{user_id}"""
        return BaseResponse(
            success=True,
            message="获取用户成功",
            data={"user_id": user_id, "name": f"用户{user_id}"}
        )

    @post('/')
    def create_user(self, name: str, email: str):
        """创建用户 - POST /api/users"""
        return BaseResponse(
            success=True,
            message="用户创建成功",
            data={"name": name, "email": email}
        )

    @put('/{user_id}')
    def update_user(self, user_id: int, name: str = None, email: str = None):
        """更新用户 - PUT /api/users/{user_id}"""
        return BaseResponse(
            success=True,
            message=f"用户 {user_id} 更新成功",
            data={"user_id": user_id, "name": name, "email": email}
        )

    @delete('/{user_id}')
    def delete_user(self, user_id: int):
        """删除用户 - DELETE /api/users/{user_id}"""
        return BaseResponse(
            success=True,
            message=f"用户 {user_id} 删除成功",
            data={"user_id": user_id}
        )

@rest_controller('/api/reports')
class ReportController:
    """报告控制器"""

    @post('/generate')  # 最终路径: POST /api/reports/generate
    def create_report(self, report_type: str):
        return {"message": "报告生成任务已创建", "type": report_type}

    @get('/status/{job_id}')  # 最终路径: GET /api/reports/status/{job_id}
    def get_status(self, job_id: str):
        return {"status": "completed", "job_id": job_id}

    @get('//health')  # 最终路径: GET /health (绝对路径)
    def health_check(self):
        return {"status": "ok"}

from myboot.core.decorators import rest_controller, get, post, service, client
from myboot.web.models import BaseResponse

@service()
class ProductService:
    def get_all(self):
        return []
    def create(self, name: str, price: float):
        return {"name": name, "price": price}

@client()
class RedisClient:
    def set(self, key: str, value):
        pass

@rest_controller('/api/products')
class ProductController:
    """产品控制器 - 使用依赖注入"""

    def __init__(self, product_service: ProductService, redis_client: RedisClient):
        # 通过构造函数自动注入
        self.product_service = product_service
        self.redis_client = redis_client

    @get('/')
    def list_products(self):
        """获取产品列表"""
        products = self.product_service.get_all()
        return BaseResponse(success=True, data={"products": products})

    @post('/')
    def create_product(self, name: str, price: float):
        """创建产品"""
        product = self.product_service.create(name, price)
        self.redis_client.set(f"product:{product['name']}", product)
        return BaseResponse(success=True, data={"product": product})

from pydantic import BaseModel
from typing import Optional
from myboot.core.decorators import rest_controller, post
from myboot.web.models import BaseResponse

class User(BaseModel):
    """用户数据模型"""
    id: Optional[int] = None
    name: str
    email: str
    age: Optional[int] = None

@rest_controller('/api/users')
class UserController:
    @post('/')
    def create_user(self, user: User):
        """创建用户"""
        return BaseResponse(success=True, message="用户创建成功", data=user.dict())

from myboot.core.decorators import rest_controller, get
from myboot.web.models import BaseResponse
from typing import Optional

@rest_controller('/api/users')
class UserController:
    @get('/')
    def get_users(self, page: int = 1, size: int = 10, search: Optional[str] = None):
        """获取用户列表（分页） - GET /api/users"""
        # 处理分页逻辑
        return BaseResponse(
            success=True,
            message="获取用户列表成功",
            data={"users": [], "total": 0, "page": page, "size": size}
        )

from myboot.core.decorators import component, cron, interval, once
from myboot.core.config import get_config

@component()
class ScheduledJobs:
    """定时任务组件"""

    @cron("0 0 * * * *", enabled=True)  # 每小时执行
    def hourly_task(self):
        print("每小时任务")

    # 从配置文件读取 enabled 状态
    @cron("0 0 2 * * *", enabled=get_config('jobs.cleanup_task.enabled', True))
    def daily_backup(self):
        """每天凌晨2点执行"""
        print("每日备份")

@component()
class MonitorJobs:
    """监控任务组件"""

    @interval(seconds=30, enabled=True)  # 每30秒执行
    def heartbeat(self):
        print("心跳检测")

    @interval(minutes=5, enabled=get_config('jobs.monitor.enabled', True))
    def monitor(self):
        """每5分钟执行"""
        print("系统监控")

@component()
class OneTimeJobs:
    """一次性任务组件"""

    @once("2025-12-31 23:59:59", enabled=True)
    def new_year_task(self):
        """新年任务 - 过期后不再执行"""
        print("新年任务")

from myboot.core.decorators import component, service, cron

@service()
class DataService:
    def sync_data(self):
        print("同步数据...")

@component()
class DataSyncJobs:
    """数据同步任务 - 自动注入 DataService"""

    def __init__(self, data_service: DataService):
        self.data_service = data_service

    @cron("0 2 * * *")  # 每天凌晨2点
    def sync_daily(self):
        self.data_service.sync_data()

# 应用配置
app:
  name: "我的应用"
  version: "1.0.0"
  debug: true

# 服务器配置
server:
  host: "0.0.0.0"
  port: 8000
  reload: true

# 数据库配置
database:
  url: "sqlite:///./app.db"
  pool_size: 10

# 任务调度配置
scheduler:
  enabled: true # 是否启用调度器
  timezone: "Asia/Shanghai" # 时区设置（可选，需要安装 pytz）
  max_workers: 10 # 最大工作线程数

# 任务启用配置（可选）
jobs:
  heartbeat:
    enabled: true
  cleanup_task:
    enabled: false
  monitor:
    enabled: true

# 日志配置
logging:
  level: "INFO" # 日志级别: DEBUG, INFO, WARNING, ERROR, CRITICAL
  format: "{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {name}:{function}:{line} - {message}"
  file: "logs/app.log" # 可选，如果配置会自动添加文件 handler
  # 第三方库日志级别配置
  third_party:
    urllib3: "WARNING"
    requests: "WARNING"
    hypercorn: "WARNING"

from myboot.core.config import get_settings, get_config, get_config_bool, get_config_str

# 方式一：使用 get_settings() 获取完整配置对象
settings = get_settings()
port = settings.get("server.port", 8000)
debug = settings.get("app.debug", False)

# 方式二：使用便捷函数（推荐）
port = get_config("server.port", 8000)
debug = get_config_bool("app.debug", False)
db_url = get_config_str("database.url", "sqlite:///./app.db")

# 在应用实例中也可以直接使用
port = app.config.get("server.port", 8000)

# 任务调度配置
scheduler:
  enabled: true # 是否启用调度器
  timezone: "Asia/Shanghai" # 时区设置（需要安装 pytz）
  max_workers: 10 # 最大工作线程数

# 获取调度器配置
config = app.scheduler.get_config()
print(config)  # {'enabled': True, 'timezone': 'Asia/Shanghai', ...}

# 列出所有任务
jobs = app.scheduler.list_all_jobs()
for job in jobs:
    print(job)

# 获取单个任务信息
job_info = app.scheduler.get_job_info('cron_app.jobs.ScheduledJobs.heartbeat')  # 0.2.0 起默认 ID 为 cron_{模块名}.{限定名}
print(job_info)

from myboot.core.decorators import component, cron, interval, once
from myboot.core.config import get_config

@component()
class TaskControlDemo:
    """任务控制示例"""

    # 方式一：直接指定
    @cron("0 */1 * * * *", enabled=True)  # 启用
    def enabled_task(self):
        print("启用状态")

    @interval(minutes=2, enabled=False)  # 禁用
    def disabled_task(self):
        print("禁用状态")

    # 方式二：从配置文件读取
    @once("2025-01-01 00:00:00", enabled=get_config('jobs.my_task.enabled', True))
    def configurable_task(self):
        print("可配置任务")

# 使用框架导出的 logger
from myboot.core.logger import logger

logger.info("应用启动")
logger.error("发生错误")
logger.debug("调试信息")
logger.warning("警告信息")

# 日志配置
logging:
  # 日志级别: DEBUG, INFO, WARNING, ERROR, CRITICAL
  level: "INFO"

  # 日志格式（支持 loguru 格式或标准 logging 格式，会自动转换）
  # 如果设置了 json: true，此选项将被忽略
  format: "{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {name}:{function}:{line} - {message}"

  # 是否使用 JSON 格式输出（适用于日志聚合和分析工具）
  # 设置为 true 时，日志以 JSON 格式输出，包含完整的结构化信息
  json: false

  # 日志文件路径（可选，如果配置会自动添加文件 handler，支持自动轮转）
  file: "logs/app.log"

  # 第三方库日志级别配置（用于控制第三方库的日志输出）
  third_party:
    urllib3: "WARNING" # 只显示 WARNING 及以上级别
    requests: "WARNING" # 只显示 WARNING 及以上级别
    hypercorn: "WARNING" # 只显示 WARNING 及以上级别
    hypercorn.error: "WARNING" # hypercorn.error logger
    asyncio: "INFO" # 显示 INFO 及以上级别

logging:
  level: "INFO"
  json: true # 启用 JSON 格式输出
  file: "logs/app.log"

format: "{time:YYYY-MM-DD HH:mm:ss} | {level: <8} | {name}:{function}:{line} - {message}"

format: "%(asctime)s - %(name)s - %(levelname)s - %(message)s"

from myboot.core.logger import logger

# 结构化日志
logger.info("用户登录", user_id=123, username="admin")

# 异常日志（自动包含堆栈跟踪）
try:
    1 / 0
except:
    logger.exception("发生错误")

# 绑定上下文信息
logger.bind(user_id=123).info("用户操作")

# 临时修改日志级别
with logger.contextualize(level="DEBUG"):
    logger.debug("这是调试信息")

# 添加自定义 handler（保留用户自定义 loguru 的能力）
from myboot.core.logger import logger
logger.add("custom.log", rotation="100 MB", retention="30 days")

from myboot.core.logger import setup_logging

# 使用默认配置初始化
setup_logging()

# 使用指定配置文件初始化
setup_logging("custom_config.yaml")

logging:
  third_party:
    urllib3: "WARNING" # 隐藏 urllib3 的 INFO 和 DEBUG 日志
    requests: "WARNING" # 隐藏 requests 的 INFO 和 DEBUG 日志
    hypercorn: "WARNING" # 隐藏 hypercorn 的 INFO 和 DEBUG 日志
    asyncio: "INFO" # 只显示 asyncio 的 INFO 及以上级别

from myboot.core.decorators import middleware
from fastapi import Request

@middleware(order=1, path_filter='/api/*')
def api_middleware(request: Request, next_handler):
    """API 中间件 - 只处理 /api/* 路径"""
    # 前置处理
    print(f"处理请求: {request.method} {request.url}")

    # 调用下一个处理器
    response = next_handler(request)

    # 后置处理
    print(f"响应状态: {response.status_code}")
    return response

@middleware(order=2, methods=['POST', 'PUT'])
def post_middleware(request: Request, next_handler):
    """POST/PUT 中间件 - 只处理 POST 和 PUT 请求"""
    # 可以在这里添加请求验证、日志记录等
    return next_handler(request)

from myboot.core.application import create_app

app = create_app(name="我的应用")

# 添加启动钩子
def startup_hook():
    """应用启动时执行"""
    print("应用启动")

app.add_startup_hook(startup_hook)

# 添加关闭钩子
def shutdown_hook():
    """应用关闭时执行"""
    print("应用关闭")

app.add_shutdown_hook(shutdown_hook)

my-app/
├── main.py              # 应用入口（根目录）
├── pyproject.toml        # 项目配置文件
├── .gitignore           # Git 忽略文件
├── app/                  # 应用代码
│   ├── api/              # API 路由
│   ├── service/          # 业务逻辑层
│   ├── model/            # 数据模型
│   ├── jobs/             # 定时任务
│   └── client/           # 客户端（第三方API调用等）
├── conf/                 # 配置文件目录
│   └── config.yaml       # 主配置文件
└── tests/                # 测试代码

from myboot.core.decorators import middleware
from fastapi import Request

@middleware(order=1)
def custom_middleware(request: Request, next_handler):
    """自定义中间件"""
    # 前置处理
    print(f"请求: {request.method} {request.url}")

    # 调用下一个处理器
    response = next_handler(request)

    # 后置处理
    print(f"响应: {response.status_code}")
    return response

from myboot.web.middleware import Middleware
from starlette.middleware.base import BaseHTTPMiddleware
from fastapi import Request

class CustomMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request: Request, call_next):
        # 中间件逻辑
        response = await call_next(request)
        return response

# 在应用初始化时添加
app.add_middleware(Middleware(CustomMiddleware))

from myboot.core.decorators import post
from myboot.utils.async_utils import asyn_run
import time

def process_data(data: dict):
    """耗时的数据处理任务"""
    print(f"开始处理数据: {data}")
    time.sleep(5)  # 模拟耗时操作
    print(f"数据处理完成: {data}")
    return {"processed": True, "data": data}

@post('/api/tasks')
def create_task(data: dict):
    """创建异步任务 - 立即返回，任务在后台执行"""
    asyn_run(process_data, data, task_name="数据处理任务")
    return {"message": "任务已创建，正在后台处理"}

from myboot.core.decorators import post, get, rest_controller
from myboot.jobs.scheduled_job import ScheduledJob
from myboot.core.scheduler import get_scheduler
import threading

@rest_controller('/api/reports')
class ReportController:
    """报告控制器"""

    def __init__(self):
        self.scheduler = get_scheduler()

    @post('/generate')
    def create_report(self, report_type: str):
        """创建报告生成任务"""
        # 创建自定义 ScheduledJob
        class ReportJob(ScheduledJob):
            def __init__(self, report_type: str):
                super().__init__(
                    name=f"生成{report_type}报告",
                    timeout=300  # 5分钟超时
                )
                self.report_type = report_type

            def run(self, *args, **kwargs):
                """生成报告任务"""
                import time
                print(f"开始生成 {self.report_type} 报告")
                time.sleep(10)  # 模拟报告生成
                return {"type": self.report_type, "status": "completed"}

        # 创建任务实例
        job = ReportJob(report_type)

        # 添加到调度器（用于状态跟踪，非定时任务）
        job_id = self.scheduler.add_job_object(job)
        thread = threading.Thread(target=job.execute)
        thread.daemon = True
        thread.start()

        return {"message": "报告生成任务已创建", "job_id": job_id}

    @get('/status/{job_id}')
    def get_status(self, job_id: str):
        """查询任务状态"""
        job = self.scheduler.get_scheduled_job(job_id)
        if job:
            return job.get_info()
        return {"error": "任务不存在"}

# 获取调度器配置
config = app.scheduler.get_config()
print(config)  # {'enabled': True, 'timezone': 'Asia/Shanghai', 'running': True, 'job_count': 3}

# 列出所有任务
jobs = app.scheduler.list_all_jobs()
for job in jobs:
    print(f"任务ID: {job['job_id']}, 类型: {job['type']}, 函数: {job['func_name']}")

# 获取单个任务信息
job_info = app.scheduler.get_job_info('cron_app.jobs.ScheduledJobs.heartbeat')  # 0.2.0 起默认 ID 为 cron_{模块名}.{限定名}
if job_info:
    print(f"Cron表达式: {job_info.get('cron')}")
    print(f"是否已执行: {job_info.get('executed', False)}")
    print(f"是否已过期: {job_info.get('expired', False)}")

# 检查调度器是否启用
if app.scheduler.is_enabled():
    print("调度器已启用")

from myboot.jobs.scheduled_job import ScheduledJob
from myboot.core.scheduler import get_scheduler
import threading

# 获取调度器
scheduler = get_scheduler()

# 创建自定义 ScheduledJob
class MyTask(ScheduledJob):
    def __init__(self, data: dict):
        super().__init__(name="my_task")
        self.data = data

    def run(self, *args, **kwargs):
        """任务函数"""
        print(f"处理数据: {self.data}")
        return {"status": "completed", "data": self.data}

# 创建任务实例
job = MyTask({"key": "value"})

# 对于非定时任务，可以直接执行
# 如果需要跟踪状态，可以添加到调度器
job_id = scheduler.add_job_object(job)

# 执行任务
result = job.execute()

# 获取任务状态
status = job.status

# 获取任务信息
job_info = job.get_info()

# 获取所有 ScheduledJob 信息
all_jobs = [job.get_info() for job in scheduler.get_all_scheduled_jobs()]

# 在后台执行任务
thread = threading.Thread(target=job.execute)
thread.daemon = True
thread.start()