faster-app 0.1.0__py3-none-any.whl

faster_api/models/base.py

@@ -0,0 +1,106 @@
+"""
+模型基类, 使用 pydantic 库管理模型
+"""
+
+from enum import IntEnum, StrEnum
+from tortoise import Model
+from tortoise.fields import (
+    IntEnumField,
+    UUIDField,
+    DatetimeField,
+    CharEnumField,
+    BooleanField,
+    TextField,
+)
+
+
+class UUIDModel(Model):
+    """模型基类"""
+
+    id = UUIDField(pk=True, verbose_name="ID")
+
+    class Meta:
+        abstract = True
+
+
+class DateTimeModel(Model):
+    """模型基类"""
+
+    created_at = DatetimeField(auto_now_add=True, verbose_name="创建时间")
+    updated_at = DatetimeField(auto_now=True, verbose_name="更新时间")
+
+    class Meta:
+        abstract = True
+
+
+class StatusModel(Model):
+    """模型基类"""
+
+    class StatusEnum(IntEnum):
+        """状态枚举"""
+
+        ACTIVE = 1
+        INACTIVE = 0
+
+    status = IntEnumField(default=1, verbose_name="状态", enum_type=StatusEnum)
+
+    class Meta:
+        abstract = True
+
+    def validate_status(self):
+        """如果状态枚举 不存在或不是 IntEnum 类型, 则抛出异常"""
+        # 检查是否存在 StatusEnum 属性
+        if not hasattr(self, "StatusEnum"):
+            raise ValueError(f"{self.__class__.__name__} 必须定义 StatusEnum")
+
+        # 检查 StatusEnum 是否是 IntEnum 的子类
+        if not (
+            isinstance(self.StatusEnum, type) and issubclass(self.StatusEnum, IntEnum)
+        ):
+            raise ValueError(
+                f"{self.__class__.__name__}.StatusEnum 必须是 IntEnum 的子类"
+            )
+
+        # 检查当前状态值是否在枚举中
+        try:
+            self.StatusEnum(self.status)
+        except ValueError:
+            valid_values = [e.value for e in self.StatusEnum]
+            raise ValueError(f"状态值 {self.status} 不在有效枚举值 {valid_values} 中")
+
+
+class ScopeModel(Model):
+    """作用域模型基类，存储作用域"""
+
+    class ScopeEnum(StrEnum):
+        """作用域枚举"""
+
+        SYSTEM = "system"
+        TENANT = "tenant"
+        PROJECT = "project"
+        OBJECT = "object"
+
+    scope = CharEnumField(ScopeEnum, default=ScopeEnum.PROJECT, verbose_name="作用域")
+
+    class Meta:
+        abstract = True
+
+
+class SyncTimeModel(Model):
+    """add sync_time field to model"""
+
+    sync_time = DatetimeField(verbose_name="同步时间", blank=True, null=True)
+
+    class Meta:
+        abstract = True
+
+
+class SyncCrontabModel(SyncTimeModel):
+    """add sync_crontab field to model"""
+
+    sync_crontab = DatetimeField(verbose_name="定时同步", null=True, blank=True)
+    sync_status = BooleanField(verbose_name="同步状态", default=False)
+    sync_error_message = TextField(verbose_name="同步错误", blank=True, null=True)
+
+    class Meta:
+        abstract = True

faster_api/models/discover.py

@@ -0,0 +1,53 @@
+"""
+自动发现 apps 目录下的 models 模块
+"""
+
+from tortoise import Model
+from faster_api.base import DiscoverBase
+
+
+class ModelDiscover(DiscoverBase):
+    """模型发现器"""
+
+    INSTANCE_TYPE = Model
+
+    TARGETS = [
+        {
+            "directory": "apps",
+            "filename": "models.py",
+            "skip_dirs": ["__pycache__"],
+            "skip_files": [],
+        },
+    ]
+
+    def discover(self) -> dict[str, list[str]]:
+        """
+        发现模型模块路径
+        返回按app分组的模块路径字典，用于Tortoise ORM的apps配置
+        """
+        apps_models = {}
+
+        # 扫描 TARGETS 中的目录和文件
+        for target in self.TARGETS:
+            files = self.walk(
+                directory=target.get("directory"),
+                filename=target.get("filename"),
+                skip_files=target.get("skip_files"),
+                skip_dirs=target.get("skip_dirs"),
+            )
+
+            for file_path in files:
+                # 将文件路径转换为模块路径
+                # 例如: apps/auth/models.py -> apps.auth.models
+                module_path = file_path.replace("/", ".").replace(".py", "")
+
+                # 提取app名称 (例如: apps.auth.models -> auth)
+                path_parts = module_path.split(".")
+                if len(path_parts) >= 3 and path_parts[0] == "apps":
+                    app_name = path_parts[1]  # auth, perm, tenant, project
+
+                    if app_name not in apps_models:
+                        apps_models[app_name] = []
+                    apps_models[app_name].append(module_path)
+
+        return apps_models

faster_api/routes/__init__.py

@@ -0,0 +1,13 @@
+"""
+路由管理模块
+
+提供了 FastAPI 路由的统一返回格式和自动发现功能
+"""
+
+from .base import ApiResponse
+from .discover import RoutesDiscover
+
+__all__ = [
+    "ApiResponse",
+    "RoutesDiscover",
+]

faster_api/routes/base.py

@@ -0,0 +1,12 @@
+"""
+统一返回格式
+"""
+
+from pydantic import BaseModel
+
+
+class ApiResponse(BaseModel):
+    """统一返回格式"""
+
+    message: str
+    data: dict

faster_api/routes/builtins/__init__.py

@@ -0,0 +1,3 @@
+"""
+内置路由模块
+"""

faster_api/routes/builtins/defaults.py

@@ -0,0 +1,12 @@
+from fastapi import APIRouter
+from settings import configs
+
+router = APIRouter()
+
+
+@router.get("/")
+async def default():
+    return {
+        "message": f"Make {configs.PROJECT_NAME} Great Again",
+        "version": configs.VERSION,
+    }

faster_api/routes/builtins/swagger.py

@@ -0,0 +1,15 @@
+from fastapi import APIRouter
+from fastapi.openapi.docs import get_swagger_ui_html
+
+router = APIRouter()
+
+
+@router.get("/docs", include_in_schema=False)
+async def custom_swagger_ui_html():
+    """自定义 Swagger UI 文档页面"""
+    return get_swagger_ui_html(
+        openapi_url="/openapi.json",
+        title="Auth Center - API 文档",
+        swagger_js_url="/static/swagger-ui-bundle.min.js",
+        swagger_css_url="/static/swagger-ui.min.css",
+    )

faster_api/routes/discover.py

@@ -0,0 +1,52 @@
+from fastapi import APIRouter
+from faster_api.base import DiscoverBase
+
+
+class RoutesDiscover(DiscoverBase):
+    INSTANCE_TYPE = APIRouter
+    TARGETS = [
+        {
+            "directory": "apps",
+            "filename": "routes.py",
+            "skip_dirs": ["__pycache__"],
+            "skip_files": [],
+        },
+        {
+            "directory": "routes/builtins",
+            "filename": None,
+            "skip_dirs": ["__pycache__"],
+            "skip_files": [],
+        },
+    ]
+
+    def import_and_extract_instances(
+        self, file_path: str, module_name: str
+    ) -> list[APIRouter]:
+        """
+        导入模块并提取路由实例
+        对于路由，我们查找已经实例化的 APIRouter 对象
+        """
+        instances = []
+
+        try:
+            # 动态导入模块
+            import importlib.util
+            import inspect
+
+            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)
+
+            # 查找模块中所有的 APIRouter 实例
+            for _, obj in inspect.getmembers(module):
+                if isinstance(obj, self.INSTANCE_TYPE):
+                    instances.append(obj)
+
+        except Exception as e:
+            # 静默跳过导入失败的模块，避免阻断整个发现过程
+            print(f"Warning: Failed to import routes from {module_name}: {e}")
+
+        return instances

faster_api/settings/__init__.py

@@ -0,0 +1,10 @@
+"""
+配置模块
+
+提供基于 pydantic-settings 的配置管理
+"""
+
+from faster_api.settings.builtins.settings import DefaultSettings
+
+# 创建默认配置实例
+configs = DefaultSettings()

faster_api/settings/builtins/settings.py

@@ -0,0 +1,64 @@
+"""
+应用配置文件
+"""
+
+from typing import Optional
+from pydantic_settings import BaseSettings
+
+
+class DefaultSettings(BaseSettings):
+    """应用设置"""
+
+    # 基础配置
+    PROJECT_NAME: str = "Faster API"
+    VERSION: str = "0.1.0"
+    DEBUG: bool = True
+
+    # Server 配置
+    HOST: str = "0.0.0.0"
+    PORT: int = 8000
+
+    # API 配置
+    API_V1_STR: str = "/api/v1"
+
+    # JWT 配置
+    SECRET_KEY: str = "your-secret-key-here-change-in-production"
+    ALGORITHM: str = "HS256"
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
+
+    # 数据库配置
+    DB_ENGINE: str = "tortoise.backends.asyncpg"
+    DB_HOST: str = "localhost"
+    DB_PORT: int = 5432
+    DB_USER: str = "postgres"
+    DB_PASSWORD: str = "postgres"
+    DB_DATABASE: str = "faster_api"
+
+    TORTOISE_ORM: Optional[dict] = {
+        "connections": {
+            "development": {
+                "engine": "tortoise.backends.sqlite",
+                "credentials": {"file_path": "faster_api.db"},
+            },
+            "production": {
+                "engine": DB_ENGINE,
+                "credentials": {
+                    "host": DB_HOST,
+                    "port": DB_PORT,
+                    "user": DB_USER,
+                    "password": DB_PASSWORD,
+                    "database": DB_DATABASE,
+                },
+            },
+        },
+        "apps": {
+            "models": {
+                # "models": ["apps.llm.models"],  # 这里不要硬编码，由自动发现填充
+                "default_connection": "development" if DEBUG else "production",
+            }
+        },
+    }
+
+    class Config:
+        env_file = ".env"
+        exclude_from_env = {"TORTOISE_ORM"}

faster_api/settings/discover.py

@@ -0,0 +1,79 @@
+"""
+自动发现 apps 目录下的 models 模块
+"""
+
+from typing import Any, Dict
+from pydantic_settings import BaseSettings
+from faster_api.base import DiscoverBase
+
+
+class SettingsDiscover(DiscoverBase):
+    """配置发现器"""
+
+    INSTANCE_TYPE = BaseSettings
+
+    TARGETS = [
+        {
+            "directory": "config",
+            "filename": None,
+            "skip_dirs": ["__pycache__"],
+            "skip_files": [],
+        },
+        {
+            "directory": "settings/builtins",
+            "filename": "settings.py",
+            "skip_dirs": ["__pycache__"],
+            "skip_files": [],
+        },
+    ]
+
+    def merge(self) -> BaseSettings:
+        """合并配置: 使用用户配置覆盖内置配置"""
+        default_settings = BaseSettings
+        user_settings = []
+
+        configs = self.discover()
+
+        for config in configs:
+            if type(config).__name__ == "DefaultSettings":
+                default_settings = config
+            else:
+                user_settings.append(config)
+
+        default_dict = default_settings.model_dump()
+
+        for user_setting in user_settings:
+            user_dict = user_setting.model_dump()
+            # 覆盖所有存在的属性
+            for key, value in user_dict.items():
+                default_dict[key] = value
+
+        # 为动态字段创建类型注解
+        annotations = {}
+        class_dict = {"__module__": __name__}
+
+        for key, value in default_dict.items():
+            # 根据值的类型推断注解
+            if isinstance(value, str):
+                annotations[key] = str
+            elif isinstance(value, int):
+                annotations[key] = int
+            elif isinstance(value, bool):
+                annotations[key] = bool
+            elif isinstance(value, dict):
+                annotations[key] = Dict[str, Any]
+            else:
+                annotations[key] = Any
+
+            # 设置默认值
+            class_dict[key] = value
+
+        # 添加类型注解
+        class_dict["__annotations__"] = annotations
+
+        # 动态创建 BaseSettings 的子类
+        MergedSettings = type("MergedSettings", (BaseSettings,), class_dict)
+
+        # 创建并返回实例
+        merged_settings = MergedSettings()
+        return merged_settings