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

jettask/webui/api/analytics.py

@@ -1,323 +0,0 @@
-"""
-分析模块 - 数据分析、查询和报表
-提供轻量级的路由入口，业务逻辑在 AnalyticsService 中实现
-"""
-from fastapi import APIRouter, HTTPException, Request, Query
-from typing import List, Dict, Optional, Any
-from datetime import datetime
-import logging
-
-from jettask.schemas import TimeRangeQuery
-from jettask.webui.services.analytics_service import AnalyticsService
-from jettask.persistence.namespace import get_namespace_data_access
-
-router = APIRouter(prefix="/analytics", tags=["analytics"])
-logger = logging.getLogger(__name__)
-
-# 获取全局数据访问实例
-data_access = get_namespace_data_access()
-
-
-# ============ 命名空间管理 ============
-
-@router.get("/namespaces")
-async def get_all_namespaces():
-    """
-    获取所有配置的命名空间列表
-    """
-    try:
-        namespaces = await data_access.get_all_namespaces()
-        return {
-            "success": True,
-            "data": namespaces
-        }
-    except Exception as e:
-        logger.error(f"获取命名空间列表失败: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-# ============ 队列统计 ============
-
-@router.get("/queue-stats/{namespace}")
-async def get_queue_stats(namespace: str):
-    """
-    获取指定命名空间的队列统计信息
-    
-    Args:
-        namespace: 命名空间名称
-    """
-    try:
-        stats = await data_access.get_queue_stats(namespace)
-        return {
-            "success": True,
-            "data": stats
-        }
-    except Exception as e:
-        logger.error(f"获取队列统计失败: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@router.post("/queue-trends/{namespace}")
-async def get_queue_trends(namespace: str, request: Request):
-    """
-    获取队列趋势数据
-    
-    Args:
-        namespace: 命名空间名称
-    """
-    try:
-        # 解析请求体
-        body = await request.json() if await request.body() else {}
-        
-        # 从请求体中获取参数
-        time_range = body.get('time_range', '1h')
-        queue_name = body.get('queue_name')
-        granularity = body.get('granularity', 'minute')
-        
-        # TODO: 实现队列趋势分析
-        return {
-            "success": True,
-            "namespace": namespace,
-            "time_range": time_range,
-            "queue_name": queue_name,
-            "data": [],
-            "granularity": granularity
-        }
-    except Exception as e:
-        logger.error(f"获取队列趋势失败: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-# ============ 任务分析 ============
-
-@router.post("/task-analysis/{namespace}")
-async def analyze_tasks(namespace: str, request: Request):
-    """
-    分析任务执行情况
-    
-    Args:
-        namespace: 命名空间名称
-    """
-    try:
-        body = await request.json()
-        
-        # TODO: 实现任务分析逻辑
-        return {
-            "success": True,
-            "data": {
-                "total_tasks": 0,
-                "success_rate": 0.0,
-                "avg_execution_time": 0.0,
-                "error_distribution": {}
-            }
-        }
-    except Exception as e:
-        logger.error(f"任务分析失败: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@router.get("/task-distribution/{namespace}")
-async def get_task_distribution(
-    namespace: str,
-    time_range: str = Query("24h", description="时间范围")
-):
-    """
-    获取任务分布情况
-    
-    Args:
-        namespace: 命名空间名称
-        time_range: 时间范围
-    """
-    try:
-        # TODO: 实现任务分布统计
-        return {
-            "success": True,
-            "data": {
-                "by_queue": {},
-                "by_status": {},
-                "by_worker": {},
-                "by_hour": []
-            }
-        }
-    except Exception as e:
-        logger.error(f"获取任务分布失败: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-# ============ 性能分析 ============
-
-@router.get("/performance-metrics/{namespace}")
-async def get_performance_metrics(
-    namespace: str,
-    time_range: str = Query("1h", description="时间范围")
-):
-    """
-    获取性能指标
-    
-    Args:
-        namespace: 命名空间名称
-        time_range: 时间范围
-    """
-    try:
-        # TODO: 实现性能指标收集
-        return {
-            "success": True,
-            "data": {
-                "throughput": 0,
-                "latency": {
-                    "p50": 0,
-                    "p95": 0,
-                    "p99": 0
-                },
-                "error_rate": 0,
-                "queue_depth": 0
-            }
-        }
-    except Exception as e:
-        logger.error(f"获取性能指标失败: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@router.get("/bottlenecks/{namespace}")
-async def identify_bottlenecks(namespace: str):
-    """
-    识别系统瓶颈
-    
-    Args:
-        namespace: 命名空间名称
-    """
-    try:
-        # TODO: 实现瓶颈分析
-        return {
-            "success": True,
-            "data": {
-                "slow_queues": [],
-                "high_error_queues": [],
-                "high_latency_tasks": [],
-                "recommendations": []
-            }
-        }
-    except Exception as e:
-        logger.error(f"识别瓶颈失败: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-# ============ 报表生成 ============
-
-@router.post("/reports/generate/{namespace}")
-async def generate_report(
-    namespace: str,
-    request: Request
-):
-    """
-    生成分析报表
-    
-    Args:
-        namespace: 命名空间名称
-    """
-    try:
-        body = await request.json()
-        report_type = body.get("report_type", "daily")
-        start_time = body.get("start_time")
-        end_time = body.get("end_time")
-        
-        # TODO: 实现报表生成
-        return {
-            "success": True,
-            "data": {
-                "report_id": f"report_{namespace}_{datetime.now().strftime('%Y%m%d%H%M%S')}",
-                "report_type": report_type,
-                "status": "generated",
-                "url": None
-            }
-        }
-    except Exception as e:
-        logger.error(f"生成报表失败: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-@router.get("/reports/{report_id}")
-async def get_report(report_id: str):
-    """
-    获取报表内容
-    
-    Args:
-        report_id: 报表ID
-    """
-    try:
-        # TODO: 实现报表获取
-        return {
-            "success": True,
-            "data": {
-                "report_id": report_id,
-                "content": {},
-                "generated_at": datetime.now().isoformat()
-            }
-        }
-    except Exception as e:
-        logger.error(f"获取报表失败: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-# ============ 实时监控 ============
-
-@router.get("/realtime/{namespace}/stats")
-async def get_realtime_stats(namespace: str):
-    """
-    获取实时统计数据
-    
-    Args:
-        namespace: 命名空间名称
-    """
-    try:
-        # TODO: 实现实时统计
-        return {
-            "success": True,
-            "data": {
-                "timestamp": datetime.now().isoformat(),
-                "active_tasks": 0,
-                "queued_tasks": 0,
-                "completed_last_minute": 0,
-                "failed_last_minute": 0,
-                "avg_processing_time": 0.0
-            }
-        }
-    except Exception as e:
-        logger.error(f"获取实时统计失败: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-# ============ 数据导出 ============
-
-@router.post("/export/{namespace}")
-async def export_data(
-    namespace: str,
-    request: Request
-):
-    """
-    导出分析数据
-    
-    Args:
-        namespace: 命名空间名称
-    """
-    try:
-        body = await request.json()
-        export_format = body.get("format", "csv")
-        data_type = body.get("data_type", "tasks")
-        
-        # TODO: 实现数据导出
-        return {
-            "success": True,
-            "data": {
-                "export_id": f"export_{namespace}_{datetime.now().strftime('%Y%m%d%H%M%S')}",
-                "format": export_format,
-                "status": "pending",
-                "url": None
-            }
-        }
-    except Exception as e:
-        logger.error(f"导出数据失败: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
-
-
-__all__ = ['router']

jettask/webui/config.py

@@ -1,90 +0,0 @@
-import os
-from typing import Optional
-from dataclasses import dataclass
-
-
-@dataclass
-class PostgreSQLConfig:
-    """PostgreSQL数据库配置"""
-    host: str = "localhost"
-    port: int = 5432
-    database: str = "jettask"
-    user: str = "jettask"
-    password: str = "123456"
-    
-    @classmethod
-    def from_env(cls) -> "PostgreSQLConfig":
-        """从环境变量中读取配置"""
-        return cls(
-            host=os.getenv("JETTASK_PG_HOST", "localhost"),
-            port=int(os.getenv("JETTASK_PG_PORT", "5432")),
-            database=os.getenv("JETTASK_PG_DATABASE", "jettask"),
-            user=os.getenv("JETTASK_PG_USER", "jettask"),
-            password=os.getenv("JETTASK_PG_PASSWORD", "123456")
-        )
-    
-    @classmethod
-    def from_url(cls, url: str) -> "PostgreSQLConfig":
-        """从数据库URL中解析配置
-        格式: postgresql://user:password@host:port/database
-        """
-        from urllib.parse import urlparse
-        
-        # 清理URL前缀（支持postgresql+asyncpg://）
-        if url.startswith('postgresql+asyncpg://'):
-            url = url.replace('postgresql+asyncpg://', 'postgresql://')
-        
-        parsed = urlparse(url)
-        
-        return cls(
-            host=parsed.hostname or "localhost",
-            port=parsed.port or 5432,
-            database=parsed.path.lstrip("/") if parsed.path else "jettask",
-            user=parsed.username or "jettask",
-            password=parsed.password or ""  # 如果没有密码返回空字符串
-        )
-    
-    @property
-    def dsn(self) -> str:
-        """返回asyncpg连接字符串"""
-        return f"postgresql://{self.user}:{self.password}@{self.host}:{self.port}/{self.database}"
-    
-    @property
-    def psycopg_dsn(self) -> str:
-        """返回psycopg连接字符串"""
-        return f"host={self.host} port={self.port} dbname={self.database} user={self.user} password={self.password}"
-
-
-@dataclass
-class RedisConfig:
-    """Redis配置"""
-    host: str = "localhost"
-    port: int = 6379
-    db: int = 0
-    password: Optional[str] = None
-    
-    @classmethod
-    def from_env(cls) -> "RedisConfig":
-        """从环境变量中读取配置"""
-        return cls(
-            host=os.getenv("JETTASK_REDIS_HOST", "localhost"),
-            port=int(os.getenv("JETTASK_REDIS_PORT", "6379")),
-            db=int(os.getenv("JETTASK_REDIS_DB", "0")),
-            password=os.getenv("JETTASK_REDIS_PASSWORD")
-        )
-
-
-@dataclass
-class WebUIConfig:
-    """WebUI配置"""
-    host: str = "0.0.0.0"
-    port: int = 8000
-    reload: bool = False
-    postgres: PostgreSQLConfig = None
-    redis: RedisConfig = None
-    
-    def __post_init__(self):
-        if self.postgres is None:
-            self.postgres = PostgreSQLConfig.from_env()
-        if self.redis is None:
-            self.redis = RedisConfig.from_env()

jettask/webui/models/__init__.py

@@ -1,3 +0,0 @@
-"""
-WebUI数据模型
-"""

jettask/webui/models/namespace.py

@@ -1,63 +0,0 @@
-"""
-任务中心数据模型
-"""
-from dataclasses import dataclass
-from typing import Optional, Dict, Any
-from datetime import datetime
-import uuid
-
-
-@dataclass
-class Namespace:
-    """命名空间模型"""
-    id: int  # 自增整数ID
-    name: str  # 唯一的命名空间名称
-    connection_url: str  # 专属连接URL
-    redis_config: Dict[str, Any]  # Redis配置
-    pg_config: Dict[str, Any]  # PostgreSQL配置
-    created_at: datetime
-    updated_at: datetime
-    metadata: Optional[Dict[str, Any]] = None
-    
-    @classmethod
-    def create(cls, name: str, redis_config: Dict, pg_config: Dict) -> 'Namespace':
-        """创建新的命名空间"""
-        # 使用名称作为URL，更直观
-        connection_url = f"/api/namespaces/{name}"
-        return cls(
-            id=0,  # 将由数据库自动分配
-            name=name,
-            connection_url=connection_url,
-            redis_config=redis_config,
-            pg_config=pg_config,
-            created_at=datetime.utcnow(),
-            updated_at=datetime.utcnow()
-        )
-
-
-@dataclass
-class TaskCenterConfig:
-    """任务中心配置"""
-    task_center_url: Optional[str] = None  # 任务中心连接URL
-    namespace_id: Optional[str] = None  # 从URL解析出的命名空间ID
-    namespace_name: Optional[str] = None  # 命名空间名称
-    
-    @property
-    def is_enabled(self) -> bool:
-        """是否启用任务中心"""
-        return self.task_center_url is not None
-    
-    @classmethod
-    def from_url(cls, url: str) -> 'TaskCenterConfig':
-        """从连接URL创建配置"""
-        if not url or not url.startswith("taskcenter://"):
-            return cls()
-        
-        # 解析URL: taskcenter://namespace/{namespace_id}
-        parts = url.replace("taskcenter://", "").split("/")
-        if len(parts) >= 2 and parts[0] == "namespace":
-            return cls(
-                task_center_url=url,
-                namespace_id=parts[1]
-            )
-        return cls(task_center_url=url)

jettask/webui/namespace_manager/__init__.py

@@ -1,10 +0,0 @@
-"""
-命名空间管理器模块
-
-提供单命名空间和多命名空间的消费者管理
-"""
-
-from .multi import NamespaceConsumerProcess
-from .unified import UnifiedConsumerManager
-
-__all__ = ['NamespaceConsumerProcess', 'UnifiedConsumerManager']