jettask 0.2.19__py3-none-any.whl → 0.2.23__py3-none-any.whl

jettask/backend/core/database.py

@@ -1,200 +0,0 @@
-"""
-Database connection management and utilities
-"""
-import asyncio
-from contextlib import asynccontextmanager
-from typing import Optional, Dict, Any, AsyncGenerator
-import asyncpg
-import redis.asyncio as redis
-from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
-from sqlalchemy.orm import DeclarativeBase
-import logging
-
-from .exceptions import DatabaseConnectionError
-
-logger = logging.getLogger(__name__)
-
-
-class DatabaseManager:
-    """数据库连接管理器"""
-    
-    def __init__(self):
-        self._pg_pools: Dict[str, asyncpg.Pool] = {}
-        self._redis_pools: Dict[str, redis.ConnectionPool] = {}
-        self._sqlalchemy_engines: Dict[str, Any] = {}
-        self._session_makers: Dict[str, async_sessionmaker] = {}
-    
-    async def get_pg_pool(self, connection_string: str, pool_name: str = "default") -> asyncpg.Pool:
-        """获取PostgreSQL连接池"""
-        if pool_name not in self._pg_pools:
-            try:
-                # 解析连接字符串
-                if connection_string.startswith('postgresql://'):
-                    connection_string = connection_string.replace('postgresql://', '')
-                elif connection_string.startswith('postgresql+asyncpg://'):
-                    connection_string = connection_string.replace('postgresql+asyncpg://', '')
-                
-                # 分离认证和主机信息
-                auth, host_info = connection_string.split('@')
-                user, password = auth.split(':')
-                host_port, database = host_info.split('/')
-                host, port = host_port.split(':')
-                
-                pool = await asyncpg.create_pool(
-                    host=host,
-                    port=int(port),
-                    user=user,
-                    password=password,
-                    database=database,
-                    min_size=2,
-                    max_size=10,
-                    command_timeout=30
-                )
-                
-                self._pg_pools[pool_name] = pool
-                logger.info(f"PostgreSQL连接池已创建: {pool_name}")
-                
-            except Exception as e:
-                logger.error(f"创建PostgreSQL连接池失败: {e}")
-                raise DatabaseConnectionError(f"PostgreSQL connection failed: {e}")
-        
-        return self._pg_pools[pool_name]
-    
-    async def get_redis_client(self, connection_string: str, pool_name: str = "default") -> redis.Redis:
-        """获取Redis客户端"""
-        if pool_name not in self._redis_pools:
-            try:
-                pool = redis.ConnectionPool.from_url(
-                    connection_string,
-                    max_connections=20,
-                    decode_responses=False  # 保持原始字节格式
-                )
-                self._redis_pools[pool_name] = pool
-                logger.info(f"Redis连接池已创建: {pool_name}")
-                
-            except Exception as e:
-                logger.error(f"创建Redis连接池失败: {e}")
-                raise DatabaseConnectionError(f"Redis connection failed: {e}")
-        
-        return redis.Redis(connection_pool=self._redis_pools[pool_name])
-    
-    def get_sqlalchemy_session_maker(
-        self, 
-        connection_string: str, 
-        pool_name: str = "default"
-    ) -> async_sessionmaker[AsyncSession]:
-        """获取SQLAlchemy会话工厂"""
-        if pool_name not in self._session_makers:
-            try:
-                # 确保使用asyncpg驱动
-                if connection_string.startswith('postgresql://'):
-                    connection_string = connection_string.replace('postgresql://', 'postgresql+asyncpg://')
-                
-                engine = create_async_engine(
-                    connection_string,
-                    pool_size=5,
-                    max_overflow=10,
-                    pool_timeout=30,
-                    pool_recycle=3600,
-                    echo=False  # 生产环境关闭SQL日志
-                )
-                
-                session_maker = async_sessionmaker(
-                    engine,
-                    class_=AsyncSession,
-                    expire_on_commit=False
-                )
-                
-                self._sqlalchemy_engines[pool_name] = engine
-                self._session_makers[pool_name] = session_maker
-                logger.info(f"SQLAlchemy会话工厂已创建: {pool_name}")
-                
-            except Exception as e:
-                logger.error(f"创建SQLAlchemy会话工厂失败: {e}")
-                raise DatabaseConnectionError(f"SQLAlchemy connection failed: {e}")
-        
-        return self._session_makers[pool_name]
-    
-    @asynccontextmanager
-    async def get_pg_connection(self, pool_name: str = "default") -> AsyncGenerator[asyncpg.Connection, None]:
-        """获取PostgreSQL连接上下文管理器"""
-        if pool_name not in self._pg_pools:
-            raise DatabaseConnectionError(f"PostgreSQL pool '{pool_name}' not found")
-        
-        pool = self._pg_pools[pool_name]
-        async with pool.acquire() as conn:
-            yield conn
-    
-    @asynccontextmanager
-    async def get_sqlalchemy_session(self, pool_name: str = "default") -> AsyncGenerator[AsyncSession, None]:
-        """获取SQLAlchemy会话上下文管理器"""
-        if pool_name not in self._session_makers:
-            raise DatabaseConnectionError(f"SQLAlchemy session maker '{pool_name}' not found")
-        
-        session_maker = self._session_makers[pool_name]
-        async with session_maker() as session:
-            try:
-                yield session
-                await session.commit()
-            except Exception:
-                await session.rollback()
-                raise
-            finally:
-                await session.close()
-    
-    async def close_all(self):
-        """关闭所有连接"""
-        # 关闭PostgreSQL连接池
-        for name, pool in self._pg_pools.items():
-            try:
-                await pool.close()
-                logger.info(f"PostgreSQL连接池已关闭: {name}")
-            except Exception as e:
-                logger.error(f"关闭PostgreSQL连接池失败 {name}: {e}")
-        
-        # 关闭Redis连接池
-        for name, pool in self._redis_pools.items():
-            try:
-                await pool.disconnect()
-                logger.info(f"Redis连接池已关闭: {name}")
-            except Exception as e:
-                logger.error(f"关闭Redis连接池失败 {name}: {e}")
-        
-        # 关闭SQLAlchemy引擎
-        for name, engine in self._sqlalchemy_engines.items():
-            try:
-                await engine.dispose()
-                logger.info(f"SQLAlchemy引擎已关闭: {name}")
-            except Exception as e:
-                logger.error(f"关闭SQLAlchemy引擎失败 {name}: {e}")
-        
-        # 清空缓存
-        self._pg_pools.clear()
-        self._redis_pools.clear()
-        self._sqlalchemy_engines.clear()
-        self._session_makers.clear()
-
-
-# 全局数据库管理器实例
-db_manager = DatabaseManager()
-
-
-# 数据库模型基类
-class Base(DeclarativeBase):
-    pass
-
-
-# 便捷函数
-async def get_pg_pool(connection_string: str, pool_name: str = "default") -> asyncpg.Pool:
-    """便捷函数：获取PostgreSQL连接池"""
-    return await db_manager.get_pg_pool(connection_string, pool_name)
-
-
-async def get_redis_client(connection_string: str, pool_name: str = "default") -> redis.Redis:
-    """便捷函数：获取Redis客户端"""
-    return await db_manager.get_redis_client(connection_string, pool_name)
-
-
-def get_session_maker(connection_string: str, pool_name: str = "default") -> async_sessionmaker[AsyncSession]:
-    """便捷函数：获取SQLAlchemy会话工厂"""
-    return db_manager.get_sqlalchemy_session_maker(connection_string, pool_name)

jettask/backend/core/exceptions.py

@@ -1,102 +0,0 @@
-"""
-Custom exceptions for JetTask WebUI Backend
-"""
-from typing import Optional, Dict, Any
-from fastapi import HTTPException
-
-
-class JetTaskAPIException(HTTPException):
-    """Base exception for JetTask API"""
-    
-    def __init__(
-        self,
-        status_code: int,
-        detail: str,
-        error_code: Optional[str] = None,
-        extra_data: Optional[Dict[str, Any]] = None
-    ):
-        super().__init__(status_code=status_code, detail=detail)
-        self.error_code = error_code
-        self.extra_data = extra_data or {}
-
-
-class NamespaceNotFoundError(JetTaskAPIException):
-    """Namespace not found error"""
-    
-    def __init__(self, namespace: str):
-        super().__init__(
-            status_code=404,
-            detail=f"Namespace '{namespace}' not found",
-            error_code="NAMESPACE_NOT_FOUND",
-            extra_data={"namespace": namespace}
-        )
-
-
-class QueueNotFoundError(JetTaskAPIException):
-    """Queue not found error"""
-    
-    def __init__(self, queue_name: str, namespace: str = "default"):
-        super().__init__(
-            status_code=404,
-            detail=f"Queue '{queue_name}' not found in namespace '{namespace}'",
-            error_code="QUEUE_NOT_FOUND",
-            extra_data={"queue_name": queue_name, "namespace": namespace}
-        )
-
-
-class TaskNotFoundError(JetTaskAPIException):
-    """Task not found error"""
-    
-    def __init__(self, task_id: str):
-        super().__init__(
-            status_code=404,
-            detail=f"Task '{task_id}' not found",
-            error_code="TASK_NOT_FOUND",
-            extra_data={"task_id": task_id}
-        )
-
-
-class ValidationError(JetTaskAPIException):
-    """Validation error"""
-    
-    def __init__(self, message: str, field: Optional[str] = None):
-        super().__init__(
-            status_code=400,
-            detail=message,
-            error_code="VALIDATION_ERROR",
-            extra_data={"field": field} if field else {}
-        )
-
-
-class DatabaseConnectionError(JetTaskAPIException):
-    """Database connection error"""
-    
-    def __init__(self, message: str = "Database connection failed"):
-        super().__init__(
-            status_code=503,
-            detail=message,
-            error_code="DATABASE_CONNECTION_ERROR"
-        )
-
-
-class RateLimitError(JetTaskAPIException):
-    """Rate limit exceeded error"""
-    
-    def __init__(self, limit: int, window: int):
-        super().__init__(
-            status_code=429,
-            detail=f"Rate limit exceeded: {limit} requests per {window} seconds",
-            error_code="RATE_LIMIT_EXCEEDED",
-            extra_data={"limit": limit, "window": window}
-        )
-
-
-class InternalServerError(JetTaskAPIException):
-    """Internal server error"""
-    
-    def __init__(self, message: str = "Internal server error"):
-        super().__init__(
-            status_code=500,
-            detail=message,
-            error_code="INTERNAL_SERVER_ERROR"
-        )

jettask/backend/dependencies.py

@@ -1,261 +0,0 @@
-"""
-Dependency injection for JetTask WebUI Backend
-"""
-from typing import Optional, AsyncGenerator
-from fastapi import Depends, HTTPException, Header
-from sqlalchemy.ext.asyncio import AsyncSession
-import redis.asyncio as redis
-
-from core.database import db_manager, DatabaseManager
-from core.cache import cache_manager, CacheManager
-from core.exceptions import NamespaceNotFoundError, DatabaseConnectionError
-from namespace_data_access import get_namespace_data_access
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-# 依赖注入函数
-
-async def get_database_manager() -> DatabaseManager:
-    """获取数据库管理器"""
-    return db_manager
-
-
-async def get_cache_manager() -> CacheManager:
-    """获取缓存管理器"""
-    return cache_manager
-
-
-async def get_namespace_from_path(namespace: str = "default") -> str:
-    """从路径参数获取命名空间"""
-    if not namespace:
-        raise HTTPException(status_code=400, detail="Namespace is required")
-    return namespace
-
-
-async def get_namespace_from_header(
-    x_namespace: Optional[str] = Header(None, alias="X-Namespace")
-) -> str:
-    """从请求头获取命名空间"""
-    return x_namespace or "default"
-
-
-async def get_current_namespace(
-    path_namespace: str = Depends(get_namespace_from_path),
-    header_namespace: str = Depends(get_namespace_from_header)
-) -> str:
-    """获取当前命名空间（优先使用路径参数）"""
-    return path_namespace if path_namespace != "default" else header_namespace
-
-
-async def validate_namespace(namespace: str) -> str:
-    """验证命名空间是否存在"""
-    try:
-        namespace_data_access = get_namespace_data_access()
-        # 尝试获取命名空间连接来验证其存在
-        conn = await namespace_data_access.manager.get_connection(namespace)
-        if not conn:
-            raise NamespaceNotFoundError(namespace)
-        return namespace
-    except Exception as e:
-        logger.error(f"命名空间验证失败 {namespace}: {e}")
-        raise NamespaceNotFoundError(namespace)
-
-
-async def get_validated_namespace(
-    namespace: str = Depends(get_current_namespace)
-) -> str:
-    """获取并验证命名空间"""
-    return await validate_namespace(namespace)
-
-
-async def get_pg_connection(
-    namespace: str = Depends(get_validated_namespace)
-) -> AsyncGenerator[object, None]:
-    """获取PostgreSQL连接"""
-    try:
-        namespace_data_access = get_namespace_data_access()
-        conn = await namespace_data_access.manager.get_connection(namespace)
-        
-        if not conn.AsyncSessionLocal:
-            raise DatabaseConnectionError("PostgreSQL not configured for this namespace")
-            
-        async with conn.AsyncSessionLocal() as session:
-            yield session
-            
-    except DatabaseConnectionError:
-        raise
-    except Exception as e:
-        logger.error(f"获取PostgreSQL连接失败: {e}")
-        raise DatabaseConnectionError(f"PostgreSQL connection failed: {e}")
-
-
-async def get_redis_client(
-    namespace: str = Depends(get_validated_namespace)
-) -> AsyncGenerator[redis.Redis, None]:
-    """获取Redis客户端"""
-    try:
-        namespace_data_access = get_namespace_data_access()
-        conn = await namespace_data_access.manager.get_connection(namespace)
-        
-        redis_client = await conn.get_redis_client(decode=False)
-        
-        try:
-            yield redis_client
-        finally:
-            await redis_client.aclose()
-            
-    except Exception as e:
-        logger.error(f"获取Redis客户端失败: {e}")
-        raise DatabaseConnectionError(f"Redis connection failed: {e}")
-
-
-async def get_namespace_connection(
-    namespace: str = Depends(get_validated_namespace)
-):
-    """获取命名空间连接对象"""
-    try:
-        namespace_data_access = get_namespace_data_access()
-        return await namespace_data_access.manager.get_connection(namespace)
-    except Exception as e:
-        logger.error(f"获取命名空间连接失败: {e}")
-        raise DatabaseConnectionError(f"Namespace connection failed: {e}")
-
-
-# 权限和认证相关依赖（预留）
-
-async def get_current_user(
-    authorization: Optional[str] = Header(None)
-) -> Optional[dict]:
-    """获取当前用户（预留接口）"""
-    # 这里可以实现JWT令牌解析、用户认证等逻辑
-    # 目前返回None表示匿名用户
-    return None
-
-
-async def require_auth(
-    current_user: Optional[dict] = Depends(get_current_user)
-) -> dict:
-    """要求用户认证（预留接口）"""
-    # 这里可以实现认证检查逻辑
-    # 目前直接返回匿名用户
-    return current_user or {"id": "anonymous", "role": "user"}
-
-
-async def require_admin(
-    current_user: dict = Depends(require_auth)
-) -> dict:
-    """要求管理员权限（预留接口）"""
-    # 这里可以实现权限检查逻辑
-    # 目前直接返回用户
-    return current_user
-
-
-# 请求验证相关依赖
-
-def validate_page_params(page: int = 1, page_size: int = 20) -> tuple[int, int]:
-    """验证分页参数"""
-    if page < 1:
-        raise HTTPException(status_code=400, detail="Page must be >= 1")
-    if page_size < 1 or page_size > 100:
-        raise HTTPException(status_code=400, detail="Page size must be between 1 and 100")
-    return page, page_size
-
-
-def validate_time_range(
-    start_time: Optional[str] = None,
-    end_time: Optional[str] = None,
-    time_range: Optional[str] = None
-) -> dict:
-    """验证时间范围参数"""
-    from datetime import datetime, timedelta
-    
-    result = {}
-    
-    if time_range:
-        # 预设时间范围
-        time_map = {
-            '15m': timedelta(minutes=15),
-            '30m': timedelta(minutes=30),
-            '1h': timedelta(hours=1),
-            '3h': timedelta(hours=3),
-            '6h': timedelta(hours=6),
-            '12h': timedelta(hours=12),
-            '24h': timedelta(hours=24),
-            '3d': timedelta(days=3),
-            '7d': timedelta(days=7),
-            '30d': timedelta(days=30)
-        }
-        
-        if time_range not in time_map:
-            raise HTTPException(
-                status_code=400, 
-                detail=f"Invalid time_range: {time_range}"
-            )
-        
-        now = datetime.now()
-        result['end_time'] = now
-        result['start_time'] = now - time_map[time_range]
-        result['time_range'] = time_range
-    
-    elif start_time or end_time:
-        # 自定义时间范围
-        try:
-            if start_time:
-                result['start_time'] = datetime.fromisoformat(start_time.replace('Z', '+00:00'))
-            if end_time:
-                result['end_time'] = datetime.fromisoformat(end_time.replace('Z', '+00:00'))
-            
-            if result.get('start_time') and result.get('end_time'):
-                if result['start_time'] >= result['end_time']:
-                    raise HTTPException(
-                        status_code=400,
-                        detail="start_time must be before end_time"
-                    )
-        except ValueError as e:
-            raise HTTPException(
-                status_code=400,
-                detail=f"Invalid datetime format: {e}"
-            )
-    
-    else:
-        # 默认最近1小时
-        now = datetime.now()
-        result['end_time'] = now
-        result['start_time'] = now - timedelta(hours=1)
-        result['time_range'] = '1h'
-    
-    return result
-
-
-# 性能监控相关依赖
-
-class RequestMetrics:
-    """请求指标收集器"""
-    
-    def __init__(self):
-        self.start_time = None
-        self.namespace = None
-        self.endpoint = None
-    
-    def start(self, namespace: str, endpoint: str):
-        import time
-        self.start_time = time.time()
-        self.namespace = namespace
-        self.endpoint = endpoint
-    
-    def finish(self):
-        if self.start_time:
-            import time
-            duration = time.time() - self.start_time
-            logger.info(
-                f"API请求完成: {self.endpoint} "
-                f"namespace={self.namespace} "
-                f"duration={duration:.3f}s"
-            )
-
-
-async def get_request_metrics() -> RequestMetrics:
-    """获取请求指标收集器"""
-    return RequestMetrics()