faster-app 0.1.0__py3-none-any.whl

faster_api/__init__.py

@@ -0,0 +1,58 @@
+"""
+Faster API - 一个轻量级的 Python Web 框架
+
+提供了以下核心功能：
+- 自动发现和加载模块 (DiscoverBase)
+- 数据库模型基类 (UUIDModel, DateTimeModel, StatusModel, ScopeModel)
+- 命令行工具基类 (CommandBase)
+- 路由管理 (ApiResponse)
+- 数据库连接管理 (tortoise_init)
+"""
+
+__version__ = "0.1.0"
+__author__ = "peizhenfei"
+__email__ = "peizhenfei@hotmail.com"
+
+# 导出主要的类和函数
+from faster_api.base import DiscoverBase
+from faster_api.models.base import (
+    UUIDModel,
+    DateTimeModel,
+    StatusModel,
+    ScopeModel,
+    SyncTimeModel,
+    SyncCrontabModel,
+)
+from faster_api.commands.base import CommandBase, with_db_init
+from faster_api.routes.base import ApiResponse
+from faster_api.db import tortoise_init
+
+# 导出发现器
+from faster_api.models.discover import ModelDiscover
+from faster_api.commands.discover import CommandDiscover
+from faster_api.routes.discover import RoutesDiscover
+
+# 导出配置
+from faster_api.settings.builtins.settings import DefaultSettings
+
+__all__ = [
+    # 基础类
+    "DiscoverBase",
+    "CommandBase",
+    "with_db_init",
+    "ApiResponse",
+    "tortoise_init",
+    # 模型基类
+    "UUIDModel",
+    "DateTimeModel",
+    "StatusModel",
+    "ScopeModel",
+    "SyncTimeModel",
+    "SyncCrontabModel",
+    # 发现器
+    "ModelDiscover",
+    "CommandDiscover",
+    "RoutesDiscover",
+    # 配置
+    "DefaultSettings",
+]

faster_api/base.py

@@ -0,0 +1,129 @@
+import os
+import importlib.util
+import inspect
+from typing import Dict, List
+
+
+class DiscoverBase(object):
+    INSTANCE_TYPE = None
+    TARGETS: List[Dict[str, str]] = []
+
+    def discover(self) -> List[type]:
+        """
+        自动扫描 TARGETS 中的目录和文件，
+        导出所有的实例
+        """
+        instances = []
+
+        # 扫描 TARGETS 中的目录和文件
+        for target in self.TARGETS:
+            instances.extend(
+                self.scan(
+                    directory=target.get("directory"),
+                    filename=target.get("filename"),
+                    skip_files=target.get("skip_files"),
+                    skip_dirs=target.get("skip_dirs"),
+                )
+            )
+        # print(instances)
+        return instances
+
+    def walk(
+        self,
+        directory: str,
+        filename: str = None,
+        skip_files: List[str] = [],
+        skip_dirs: List[str] = [],
+    ) -> List[str]:
+        """
+        遍历目录下的所有文件
+        """
+        results = []
+        if not os.path.exists(directory) or not os.path.isdir(directory):
+            return results
+
+        for root, dirs, files in os.walk(directory):
+            # 过滤掉需要跳过的目录，直接修改 dirs 列表来影响 os.walk 的遍历
+            dirs[:] = [d for d in dirs if d not in skip_dirs]
+
+            for file in files:
+                if filename is None or file == filename:
+                    if file in skip_files:
+                        continue
+                    # 只处理 .py 文件
+                    if file.endswith(".py"):
+                        results.append(os.path.join(root, file))
+        return results
+
+    def scan(
+        self,
+        directory: str,
+        filename: str = None,
+        skip_files: List[str] = [],
+        skip_dirs: List[str] = [],
+    ) -> List[type]:
+        """
+        通用扫描方法
+
+        Args:
+            directory: 要扫描的目录路径
+            filename: 要扫描的具体文件名，如果为 None 则扫描目录下所有 .py 文件
+            skip_files: 要跳过的文件列表
+            skip_dirs: 要跳过的目录列表
+        Returns:
+            扫描到的所有实例列表
+        """
+        instances = []
+
+        files = self.walk(directory, filename, skip_files, skip_dirs)
+
+        for file in files:
+            instances.extend(
+                self.import_and_extract_instances(file, file.split("/")[-1][:-3])
+            )
+
+        return instances
+
+    def import_and_extract_instances(
+        self, file_path: str, module_name: str
+    ) -> List[type]:
+        """
+        导入模块并提取实例
+
+        Args:
+            file_path: 文件路径
+            module_name: 模块名称
+
+        Returns:
+            提取到的实例列表
+        """
+        instances = []
+
+        try:
+            # 动态导入模块
+            spec = importlib.util.spec_from_file_location(module_name, file_path)
+            if spec is None or spec.loader is None:
+                return instances
+
+            module = importlib.util.module_from_spec(spec)
+            spec.loader.exec_module(module)
+
+            # 查找模块中所有的类并实例化
+            for _, obj in inspect.getmembers(module):
+                if (
+                    inspect.isclass(obj)
+                    and issubclass(obj, self.INSTANCE_TYPE)
+                    and obj != self.INSTANCE_TYPE
+                ):
+                    try:
+                        # 实例化命令类
+                        instance = obj()
+                        instances.append(instance)
+                    except Exception as e:
+                        print(f"Warning: Failed to instantiate {obj.__name__}: {e}")
+
+        except Exception as e:
+            # 静默跳过导入失败的模块，避免阻断整个发现过程
+            print(f"Warning: Failed to import instances from {module_name}: {e}")
+
+        return instances

faster_api/commands/__init__.py

@@ -0,0 +1,14 @@
+"""
+命令行工具模块
+
+提供了基于 Fire 的命令行工具基类和自动发现功能
+"""
+
+from .base import CommandBase, with_db_init
+from .discover import CommandDiscover
+
+__all__ = [
+    "CommandBase",
+    "with_db_init",
+    "CommandDiscover",
+]

faster_api/commands/base.py

@@ -0,0 +1,85 @@
+"""
+命令基类, 使用 fire 库管理子命令
+"""
+
+import inspect
+from functools import wraps
+from tortoise import Tortoise
+from faster_api.db import tortoise_init
+
+
+def with_db_init(func):
+    """装饰器：为异步方法自动初始化和关闭数据库连接"""
+
+    @wraps(func)
+    async def wrapper(*args, **kwargs):
+        # 初始化数据库连接
+        await tortoise_init()
+        try:
+            # 执行原方法
+            result = await func(*args, **kwargs)
+            return result
+        finally:
+            # 关闭数据库连接
+            if Tortoise._inited:
+                await Tortoise.close_connections()
+
+    return wrapper
+
+
+class CommandBase(object):
+    """命令基类"""
+
+    # 默认要去掉的后缀列表
+    DEFAULT_SUFFIXES = [
+        "Command",
+        "Commands",
+        "Handler",
+        "Handlers",
+        "Operations",
+        "Operation",
+    ]
+
+    def __getattribute__(self, name):
+        """自动为异步方法添加数据库初始化装饰器"""
+        attr = object.__getattribute__(self, name)
+
+        # 如果是方法且是异步的，自动添加数据库初始化装饰器
+        if (
+            inspect.iscoroutinefunction(attr)
+            and not name.startswith("_")
+            and not hasattr(attr, "_db_wrapped")
+        ):
+            wrapped_attr = with_db_init(attr)
+            wrapped_attr._db_wrapped = True  # 标记已包装，避免重复包装
+            return wrapped_attr
+
+        return attr
+
+    @classmethod
+    def get_command_name(cls, class_name: str = None, suffixes: list = None) -> str:
+        """
+        自动去除类名中的常见后缀，生成简洁的命令名
+
+        Args:
+            class_name: 类名，如果不提供则使用当前类的名称
+            suffixes: 要去除的后缀列表，如果不提供则使用默认后缀
+
+        Returns:
+            去除后缀后的命令名（小写）
+        """
+        if class_name is None:
+            class_name = cls.__name__
+
+        if suffixes is None:
+            suffixes = cls.DEFAULT_SUFFIXES
+
+        # 按照后缀长度从长到短排序，优先匹配较长的后缀
+        sorted_suffixes = sorted(suffixes, key=len, reverse=True)
+
+        for suffix in sorted_suffixes:
+            if class_name.endswith(suffix):
+                return class_name[: -len(suffix)].lower()
+
+        # 如果没有匹配的后缀，直接返回小写的类名
+        return class_name.lower()

faster_api/commands/builtins/__init__.py

@@ -0,0 +1,3 @@
+"""
+内置命令模块
+"""

faster_api/commands/builtins/db.py

@@ -0,0 +1,137 @@
+"""系统内置命令"""
+
+import os
+import shutil
+from faster_api.commands.base import CommandBase
+from rich.console import Console
+from faster_api.settings.builtins.settings import DefaultSettings
+from faster_api.models.discover import ModelDiscover
+from aerich import Command
+
+console = Console()
+
+
+class DBOperations(CommandBase):
+    """数据库操作命令 - 使用Aerich管理数据库迁移"""
+
+    def __init__(self, fake: bool = False):
+        self.fake = fake
+        self.command = Command(
+            tortoise_config=self._get_tortoise_config(), app="aerich"
+        )
+
+    def _get_tortoise_config(self):
+        """获取Tortoise ORM配置"""
+        apps_models = ModelDiscover().discover()
+        # print("--->", apps_models)  # 注释掉调试输出
+        configs = DefaultSettings()
+        tortoise_config = configs.TORTOISE_ORM.copy()
+
+        # 清空原有的apps配置
+        tortoise_config["apps"] = {}
+
+        # 为每个app创建配置
+        for app_name, models in apps_models.items():
+            tortoise_config["apps"][app_name] = {
+                "models": models,
+                "default_connection": "development" if configs.DEBUG else "production",
+            }
+
+        # 添加aerich模型到一个单独的app中
+        tortoise_config["apps"]["aerich"] = {
+            "models": ["aerich.models"],
+            "default_connection": "development" if configs.DEBUG else "production",
+        }
+
+        return tortoise_config
+
+    async def init_db(self):
+        """初始化数据库（首次创建表）"""
+        try:
+            await self.command.init_db(safe=True)
+            console.print("✅ 数据库初始化成功")
+        except Exception as e:
+            console.print(f"❌ 数据库初始化失败: {e}")
+        finally:
+            await self.command.close()
+
+    async def migrate(self):
+        """执行数据库迁移"""
+        try:
+            await self.command.init()
+            await self.command.migrate()
+            console.print("✅ 数据库迁移执行成功")
+        except Exception as e:
+            console.print(f"❌ 数据库迁移执行失败: {e}")
+        finally:
+            await self.command.close()
+
+    async def upgrade(self):
+        """执行数据库迁移"""
+        try:
+            await self.command.init()
+            await self.command.upgrade(fake=self.fake)
+            console.print("✅ 数据库迁移执行成功")
+        except Exception as e:
+            console.print(f"❌ 数据库迁移执行失败: {e}")
+        finally:
+            await self.command.close()
+
+    async def downgrade(self, version: int = -1):
+        """回滚数据库迁移"""
+        try:
+            await self.command.init()
+            await self.command.downgrade(version=version, delete=True, fake=self.fake)
+            console.print("✅ 数据库回滚成功")
+        except Exception as e:
+            console.print(f"❌ 数据库回滚失败: {e}")
+        finally:
+            await self.command.close()
+
+    async def history(self):
+        """查看迁移历史"""
+        try:
+            await self.command.init()
+            history = await self.command.history()
+            console.print("✅ 迁移历史:")
+            for record in history:
+                console.print(f"  - {record}")
+
+        except Exception as e:
+            console.print(f"❌ 查看迁移历史失败: {e}")
+        finally:
+            await self.command.close()
+
+    async def heads(self):
+        """查看当前迁移头部"""
+        try:
+            await self.command.init()
+            heads = await self.command.heads()
+            console.print("✅ 当前迁移头部:")
+            for record in heads:
+                console.print(f"  - {record}")
+        except Exception as e:
+            console.print(f"❌ 查看当前迁移头部失败: {e}")
+        finally:
+            await self.command.close()
+
+    async def dev_clean(self):
+        """清理开发环境数据
+        1. 移除 sqlite 数据库文件
+        2. 移除 aerich 迁移记录
+        """
+        try:
+            # 删除数据库文件
+            db_file = f"{configs.DB_DATABASE}.db"
+            if os.path.exists(db_file):
+                os.remove(db_file)
+                console.print(f"✅ 已删除数据库文件: {db_file}")
+
+            # 递归删除 migrations 目录
+            if os.path.exists("migrations"):
+                shutil.rmtree("migrations")
+                console.print("✅ 已删除迁移目录: migrations")
+
+            console.print("✅ 开发环境数据清理成功")
+        except Exception as e:
+            console.print(f"❌ 清理开发环境数据失败: {e}")

faster_api/commands/builtins/fastapi.py

@@ -0,0 +1,87 @@
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+from tortoise import Tortoise
+from faster_api.settings.builtins.settings import DefaultSettings
+from rich.console import Console
+from starlette.staticfiles import StaticFiles
+from faster_api.commands.base import CommandBase
+from faster_api.db import tortoise_init
+import uvicorn
+import threading
+
+from faster_api.routes.discover import RoutesDiscover
+
+console = Console()
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    await tortoise_init()
+    yield
+    await Tortoise.close_connections()
+
+
+class FastAPIAppSingleton:
+    """线程安全的FastAPI应用单例类"""
+
+    _instance = None
+    _lock = threading.Lock()
+
+    def __new__(cls):
+        if cls._instance is None:
+            with cls._lock:
+                # 双重检查锁定模式
+                if cls._instance is None:
+                    cls._instance = cls._create_app()
+        return cls._instance
+
+    @classmethod
+    def _create_app(cls):
+        """创建FastAPI应用实例"""
+        # 创建FastAPI应用实例
+        configs = DefaultSettings()
+        app = FastAPI(
+            title=configs.PROJECT_NAME,
+            version=configs.VERSION,
+            debug=configs.DEBUG,
+            lifespan=lifespan,
+            docs_url=None,
+            redoc_url=None,
+        )
+
+        # 添加静态文件服务器
+        try:
+            import os
+
+            static_dir = os.path.join(os.path.dirname(__file__), "..", "..", "statics")
+            app.mount("/static", StaticFiles(directory=static_dir), name="static")
+        except Exception as e:
+            console.print(f"静态文件服务器启动失败: {e}")
+
+        # 添加路由
+        routes = RoutesDiscover().discover()
+        for route in routes:
+            app.include_router(route)
+
+        return app
+
+
+app = FastAPIAppSingleton()
+
+
+class FastApiOperations(CommandBase):
+    def __init__(self, host: str = None, port: int = None):
+        configs = DefaultSettings()
+        self.host = host or configs.HOST
+        self.port = port or configs.PORT
+        self.configs = configs
+
+    def start(self):
+        # 启动服务
+        reload = True if self.configs.DEBUG else False
+        uvicorn.run(
+            "faster_api.commands.builtins.fastapi:app",
+            host=self.host,
+            port=self.port,
+            reload=reload,
+        )

faster_api/commands/discover.py

@@ -0,0 +1,24 @@
+"""
+自动发现 apps 目录下的 commands 模块和内置命令
+"""
+
+from faster_api.commands.base import CommandBase
+from faster_api.base import DiscoverBase
+
+
+class CommandDiscover(DiscoverBase):
+    INSTANCE_TYPE = CommandBase
+    TARGETS = [
+        {
+            "directory": "apps",
+            "filename": "commands.py",
+            "skip_dirs": ["__pycache__"],
+            "skip_files": [],
+        },
+        {
+            "directory": "commands/builtins",
+            "filename": None,
+            "skip_dirs": ["__pycache__"],
+            "skip_files": [],
+        },
+    ]

faster_api/db.py

@@ -0,0 +1,32 @@
+from tortoise import Tortoise
+from faster_api.models.discover import ModelDiscover
+
+
+async def tortoise_init(tortoise_config: dict = None):
+    """
+    初始化Tortoise ORM
+
+    Args:
+        tortoise_config: Tortoise ORM 配置字典，如果不提供则使用默认配置
+    """
+    if not Tortoise._inited:
+        if tortoise_config is None:
+            # 提供一个默认的配置示例
+            tortoise_config = {
+                "connections": {"default": "sqlite://db.sqlite3"},
+                "apps": {},
+                "use_tz": False,
+                "timezone": "UTC",
+            }
+
+        # 自动发现模型并添加到配置中
+        apps_models = ModelDiscover().discover()
+
+        # 为每个app创建配置
+        for app_name, models in apps_models.items():
+            tortoise_config["apps"][app_name] = {
+                "models": models,
+                "default_connection": "default",
+            }
+
+        await Tortoise.init(config=tortoise_config)

faster_api/models/__init__.py

@@ -0,0 +1,21 @@
+"""
+数据库模型模块
+
+提供了基于 Tortoise ORM 的模型基类和自动发现功能
+"""
+
+from .base import (
+    UUIDModel,
+    DateTimeModel,
+    StatusModel,
+    ScopeModel,
+)
+from .discover import ModelDiscover
+
+__all__ = [
+    "UUIDModel",
+    "DateTimeModel",
+    "StatusModel",
+    "ScopeModel",
+    "ModelDiscover",
+]