aigroup-econ-mcp 0.3.5__tar.gz → 0.3.6__tar.gz

{aigroup_econ_mcp-0.3.5 → aigroup_econ_mcp-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aigroup-econ-mcp
-Version: 0.3.5
+Version: 0.3.6
 Summary: 专业计量经济学MCP工具 - 让大模型直接进行数据分析
 Project-URL: Homepage, https://github.com/aigroup/aigroup-econ-mcp
 Project-URL: Repository, https://github.com/aigroup/aigroup-econ-mcp.git

{aigroup_econ_mcp-0.3.5 → aigroup_econ_mcp-0.3.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "aigroup-econ-mcp"
-version = "0.3.5"
+version = "0.3.6"
 description = "专业计量经济学MCP工具 - 让大模型直接进行数据分析"
 readme = "README.md"
 requires-python = ">=3.10"

{aigroup_econ_mcp-0.3.5 → aigroup_econ_mcp-0.3.6}/src/aigroup_econ_mcp/__init__.py

@@ -10,7 +10,7 @@ AIGroup 计量经济学 MCP 服务
 - 模型诊断
 """
 
-__version__ = "0.3.4"
+__version__ = "0.3.6"
 __author__ = "AIGroup"
 __description__ = "专业计量经济学MCP工具 - 让大模型直接进行数据分析"
 

{aigroup_econ_mcp-0.3.5 → aigroup_econ_mcp-0.3.6}/src/aigroup_econ_mcp/server.py

@@ -9,6 +9,9 @@ from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from dataclasses import dataclass
 import importlib.metadata
+import json
+import os
+from pathlib import Path
 
 import pandas as pd
 import numpy as np
@@ -21,6 +24,55 @@ from mcp.server.fastmcp import FastMCP, Context
 from mcp.server.session import ServerSession
 from mcp.types import CallToolResult, TextContent
 
+# 导入超时管理器
+from .tools.timeout import TimeoutManager
+
+
+# 性能配置加载函数
+def load_performance_config() -> Dict[str, Any]:
+    """加载性能配置"""
+    config_paths = [
+        Path("config/performance_config.json"),
+        Path("performance_config.json"),
+        Path.cwd() / "config" / "performance_config.json"
+    ]
+    
+    for config_path in config_paths:
+        if config_path.exists():
+            try:
+                with open(config_path, 'r', encoding='utf-8') as f:
+                    config = json.load(f)
+                print(f"✅ 性能配置已加载: {config_path}")
+                return config
+            except Exception as e:
+                print(f"⚠️ 加载性能配置失败 {config_path}: {e}")
+    
+    # 返回默认配置
+    default_config = {
+        "performance": {
+            "cache": {"enabled": True, "ttl": 3600, "max_size": 1000},
+            "monitoring": {"enabled": True, "memory_check_interval": 1.0},
+            "timeouts": {
+                "simple_models": 30,
+                "complex_models": 120,
+                "machine_learning": 300,
+                "time_series": 180
+            }
+        },
+        "models": {
+            "descriptive_statistics": {"timeout": 30},
+            "ols_regression": {"timeout": 60},
+            "time_series_analysis": {"timeout": 120},
+            "panel_data_analysis": {"timeout": 180},
+            "var_model": {"timeout": 300},
+            "garch_model": {"timeout": 240},
+            "random_forest": {"timeout": 300},
+            "gradient_boosting": {"timeout": 300}
+        }
+    }
+    print("⚠️ 使用默认性能配置")
+    return default_config
+
 
 # 数据模型定义 - 使用Pydantic实现结构化输出
 class DescriptiveStatsResult(BaseModel):
@@ -70,6 +122,8 @@ class AppContext:
     """应用上下文，包含共享资源"""
     config: Dict[str, Any]
     version: str = importlib.metadata.version("aigroup-econ-mcp")
+    performance_config: Dict[str, Any] = None
+    timeout_manager: Any = None
 
 
 # 服务器图标（已移除，因为MCP库不再支持Icon类）
@@ -86,8 +140,19 @@ async def lifespan(server: FastMCP) -> AsyncIterator[AppContext]:
         "data_types": ["cross_section", "time_series", "panel"]
     }
 
+    # 加载性能配置
+    performance_config = load_performance_config()
+    
+    # 初始化超时管理器
+    timeout_manager = TimeoutManager(performance_config.get("timeouts", {}))
+    
     try:
-        yield AppContext(config=config, version=importlib.metadata.version("aigroup-econ-mcp"))
+        yield AppContext(
+            config=config, 
+            version=importlib.metadata.version("aigroup-econ-mcp"),
+            performance_config=performance_config,
+            timeout_manager=timeout_manager
+        )
     finally:
         # 清理资源
         pass
@@ -202,51 +267,44 @@ async def descriptive_statistics(
     await ctx.info(f"开始计算描述性统计，处理 {len(data)} 个变量")
 
     try:
-        # 数据验证
-        if not data:
-            raise ValueError("数据不能为空")
+        # 获取超时管理器
+        timeout_manager = ctx.session.context.timeout_manager
+        model_timeout = ctx.session.context.performance_config.get("models", {}).get("descriptive_statistics", {}).get("timeout", 30)
         
-        df = pd.DataFrame(data)
-        
-        # 检查数据一致性
-        if len(df.columns) == 0:
-            raise ValueError("至少需要一个变量")
-        
-        # 基础统计量 - 修复：返回所有变量的综合统计
-        result = DescriptiveStatsResult(
-            count=len(df),
-            mean=df.mean().mean(),  # 所有变量的均值
-            std=df.std().mean(),    # 所有变量的标准差均值
-            min=df.min().min(),     # 所有变量的最小值
-            max=df.max().max(),     # 所有变量的最大值
-            median=df.median().mean(),  # 所有变量的中位数均值
-            skewness=df.skew().mean(),  # 所有变量的偏度均值
-            kurtosis=df.kurtosis().mean()  # 所有变量的峰度均值
+        # 使用超时控制执行计算
+        result = await timeout_manager.execute_with_timeout(
+            model_name="descriptive_statistics",
+            timeout_seconds=model_timeout,
+            func=_compute_descriptive_stats,
+            data=data
         )
 
-        # 计算相关系数矩阵
-        correlation_matrix = df.corr().round(4)
-
-        await ctx.info(f"描述性统计计算完成，样本大小: {len(df)}")
+        await ctx.info(f"描述性统计计算完成，样本大小: {result['count']}")
 
         return CallToolResult(
             content=[
                 TextContent(
                     type="text",
                     text=f"描述性统计结果：\n"
-                         f"均值: {result.mean:.4f}\n"
-                         f"标准差: {result.std:.4f}\n"
-                         f"最小值: {result.min:.4f}\n"
-                         f"最大值: {result.max:.4f}\n"
-                         f"中位数: {result.median:.4f}\n"
-                         f"偏度: {result.skewness:.4f}\n"
-                         f"峰度: {result.kurtosis:.4f}\n\n"
-                         f"相关系数矩阵：\n{correlation_matrix.to_string()}"
+                         f"均值: {result['mean']:.4f}\n"
+                         f"标准差: {result['std']:.4f}\n"
+                         f"最小值: {result['min']:.4f}\n"
+                         f"最大值: {result['max']:.4f}\n"
+                         f"中位数: {result['median']:.4f}\n"
+                         f"偏度: {result['skewness']:.4f}\n"
+                         f"峰度: {result['kurtosis']:.4f}\n\n"
+                         f"相关系数矩阵：\n{result['correlation_matrix']}"
                 )
             ],
-            structuredContent=result.model_dump()
+            structuredContent=result
         )
 
+    except TimeoutError:
+        await ctx.error("描述性统计计算超时，请减少数据量或调整配置")
+        return CallToolResult(
+            content=[TextContent(type="text", text="错误: 计算超时，请减少数据量或调整配置")],
+            isError=True
+        )
     except Exception as e:
         await ctx.error(f"计算描述性统计时出错: {str(e)}")
         return CallToolResult(
@@ -255,6 +313,37 @@ async def descriptive_statistics(
         )
 
 
+def _compute_descriptive_stats(data: Dict[str, List[float]]) -> Dict[str, Any]:
+    """计算描述性统计（同步函数，用于超时控制）"""
+    # 数据验证
+    if not data:
+        raise ValueError("数据不能为空")
+    
+    df = pd.DataFrame(data)
+    
+    # 检查数据一致性
+    if len(df.columns) == 0:
+        raise ValueError("至少需要一个变量")
+    
+    # 基础统计量
+    result = {
+        "count": len(df),
+        "mean": float(df.mean().mean()),  # 所有变量的均值
+        "std": float(df.std().mean()),    # 所有变量的标准差均值
+        "min": float(df.min().min()),     # 所有变量的最小值
+        "max": float(df.max().max()),     # 所有变量的最大值
+        "median": float(df.median().mean()),  # 所有变量的中位数均值
+        "skewness": float(df.skew().mean()),  # 所有变量的偏度均值
+        "kurtosis": float(df.kurtosis().mean())  # 所有变量的峰度均值
+    }
+
+    # 计算相关系数矩阵
+    correlation_matrix = df.corr().round(4)
+    result["correlation_matrix"] = correlation_matrix.to_string()
+    
+    return result
+
+
 @mcp.tool()
 async def ols_regression(
     ctx: Context[ServerSession, AppContext],
@@ -342,59 +431,18 @@ async def ols_regression(
     await ctx.info(f"开始OLS回归分析，样本大小: {len(y_data)}，自变量数量: {len(x_data[0]) if x_data else 0}")
 
     try:
-        # 数据验证
-        if not y_data:
-            raise ValueError("因变量数据不能为空")
-        if not x_data:
-            raise ValueError("自变量数据不能为空")
-        if len(y_data) != len(x_data):
-            raise ValueError(f"因变量和自变量的观测数量不一致: y_data={len(y_data)}, x_data={len(x_data)}")
-        
-        # 准备数据
-        X = np.array(x_data)
-        y = np.array(y_data)
-        
-        # 添加常数项
-        X_with_const = sm.add_constant(X)
-
-        # 拟合模型
-        model = sm.OLS(y, X_with_const).fit()
-
-        # 构建系数字典
-        conf_int = model.conf_int()
-        coefficients = {}
+        # 获取超时管理器
+        timeout_manager = ctx.session.context.timeout_manager
+        model_timeout = ctx.session.context.performance_config.get("models", {}).get("ols_regression", {}).get("timeout", 60)
         
-        # 修复：正确处理feature_names为None的情况
-        if feature_names is None:
-            feature_names = [f"x{i+1}" for i in range(X.shape[1])]
-        elif len(feature_names) != X.shape[1]:
-            await ctx.warning(f"提供的feature_names数量({len(feature_names)})与自变量数量({X.shape[1]})不匹配，使用默认命名")
-            feature_names = [f"x{i+1}" for i in range(X.shape[1])]
-
-        for i, coef in enumerate(model.params):
-            if i == 0:
-                var_name = "const"
-            else:
-                var_name = feature_names[i-1]
-            
-            coefficients[var_name] = {
-                "coef": float(coef),  # 转换numpy.float64为float
-                "std_err": float(model.bse[i]),
-                "t_value": float(model.tvalues[i]),
-                "p_value": float(model.pvalues[i]),
-                "ci_lower": float(conf_int[i][0]),
-                "ci_upper": float(conf_int[i][1])
-            }
-        
-        # 构建结果
-        result = OLSRegressionResult(
-            rsquared=float(model.rsquared),
-            rsquared_adj=float(model.rsquared_adj),
-            f_statistic=float(model.fvalue),
-            f_pvalue=float(model.f_pvalue),
-            aic=float(model.aic),
-            bic=float(model.bic),
-            coefficients=coefficients
+        # 使用超时控制执行计算
+        result = await timeout_manager.execute_with_timeout(
+            model_name="ols_regression",
+            timeout_seconds=model_timeout,
+            func=_compute_ols_regression,
+            y_data=y_data,
+            x_data=x_data,
+            feature_names=feature_names
         )
 
         await ctx.info("OLS回归分析完成")
@@ -404,16 +452,22 @@ async def ols_regression(
                 TextContent(
                     type="text",
                     text=f"OLS回归分析结果：\n"
-                         f"R² = {result.rsquared:.4f}\n"
-                         f"调整R² = {result.rsquared_adj:.4f}\n"
-                         f"F统计量 = {result.f_statistic:.4f} (p = {result.f_pvalue:.4f})\n"
-                         f"AIC = {result.aic:.2f}, BIC = {result.bic:.2f}\n\n"
-                         f"回归系数：\n{model.summary().tables[1]}"
+                         f"R² = {result['rsquared']:.4f}\n"
+                         f"调整R² = {result['rsquared_adj']:.4f}\n"
+                         f"F统计量 = {result['f_statistic']:.4f} (p = {result['f_pvalue']:.4f})\n"
+                         f"AIC = {result['aic']:.2f}, BIC = {result['bic']:.2f}\n\n"
+                         f"回归系数：\n{result['summary_table']}"
                 )
             ],
-            structuredContent=result.model_dump()
+            structuredContent=result
         )
 
+    except TimeoutError:
+        await ctx.error("OLS回归分析超时，请减少数据量或调整配置")
+        return CallToolResult(
+            content=[TextContent(type="text", text="错误: 计算超时，请减少数据量或调整配置")],
+            isError=True
+        )
     except Exception as e:
         await ctx.error(f"OLS回归分析出错: {str(e)}")
         return CallToolResult(
@@ -422,6 +476,66 @@ async def ols_regression(
         )
 
 
+def _compute_ols_regression(y_data: List[float], x_data: List[List[float]], feature_names: Optional[List[str]] = None) -> Dict[str, Any]:
+    """计算OLS回归（同步函数，用于超时控制）"""
+    # 数据验证
+    if not y_data:
+        raise ValueError("因变量数据不能为空")
+    if not x_data:
+        raise ValueError("自变量数据不能为空")
+    if len(y_data) != len(x_data):
+        raise ValueError(f"因变量和自变量的观测数量不一致: y_data={len(y_data)}, x_data={len(x_data)}")
+    
+    # 准备数据
+    X = np.array(x_data)
+    y = np.array(y_data)
+    
+    # 添加常数项
+    X_with_const = sm.add_constant(X)
+
+    # 拟合模型
+    model = sm.OLS(y, X_with_const).fit()
+
+    # 构建系数字典
+    conf_int = model.conf_int()
+    coefficients = {}
+    
+    # 处理feature_names
+    if feature_names is None:
+        feature_names = [f"x{i+1}" for i in range(X.shape[1])]
+    elif len(feature_names) != X.shape[1]:
+        feature_names = [f"x{i+1}" for i in range(X.shape[1])]
+
+    for i, coef in enumerate(model.params):
+        if i == 0:
+            var_name = "const"
+        else:
+            var_name = feature_names[i-1]
+        
+        coefficients[var_name] = {
+            "coef": float(coef),
+            "std_err": float(model.bse[i]),
+            "t_value": float(model.tvalues[i]),
+            "p_value": float(model.pvalues[i]),
+            "ci_lower": float(conf_int[i][0]),
+            "ci_upper": float(conf_int[i][1])
+        }
+    
+    # 构建结果
+    result = {
+        "rsquared": float(model.rsquared),
+        "rsquared_adj": float(model.rsquared_adj),
+        "f_statistic": float(model.fvalue),
+        "f_pvalue": float(model.f_pvalue),
+        "aic": float(model.aic),
+        "bic": float(model.bic),
+        "coefficients": coefficients,
+        "summary_table": str(model.summary().tables[1])
+    }
+    
+    return result
+
+
 @mcp.tool()
 async def hypothesis_testing(
     ctx: Context[ServerSession, AppContext],

aigroup_econ_mcp-0.3.6/src/aigroup_econ_mcp/tools/timeout.py

@@ -0,0 +1,283 @@
+"""
+超时控制模块
+为复杂计算任务提供超时控制和资源管理
+"""
+
+import asyncio
+import signal
+import threading
+import time
+from typing import Any, Callable, Optional, TypeVar, Union
+from functools import wraps
+from contextlib import contextmanager
+import warnings
+
+T = TypeVar('T')
+
+
+class TimeoutError(Exception):
+    """超时错误"""
+    pass
+
+
+class TimeoutManager:
+    """
+    超时管理器
+    提供同步和异步的超时控制
+    """
+    
+    def __init__(self):
+        self._timeout_config = {}
+    
+    def set_timeout_config(self, config: dict) -> None:
+        """设置超时配置"""
+        self._timeout_config = config
+    
+    def get_timeout_for_function(self, function_name: str, default: int = 60) -> int:
+        """获取函数的超时时间"""
+        # 从配置中获取超时时间
+        if function_name in self._timeout_config:
+            return self._timeout_config[function_name]
+        
+        # 根据函数类型返回默认超时
+        if function_name.startswith(('descriptive_', 'correlation_')):
+            return 30
+        elif function_name.startswith(('ols_', 'hypothesis_')):
+            return 60
+        elif function_name.startswith(('time_series_', 'panel_')):
+            return 120
+        elif function_name.startswith(('var_', 'vecm_', 'garch_')):
+            return 180
+        elif function_name.startswith(('random_forest_', 'gradient_boosting_')):
+            return 300
+        else:
+            return default
+    
+    async def execute_with_timeout(self, model_name: str, timeout_seconds: int, func: callable, *args, **kwargs):
+        """使用超时执行函数"""
+        try:
+            if asyncio.iscoroutinefunction(func):
+                # 异步函数
+                return await asyncio.wait_for(
+                    func(*args, **kwargs),
+                    timeout=timeout_seconds
+                )
+            else:
+                # 同步函数 - 在线程池中执行
+                loop = asyncio.get_event_loop()
+                return await loop.run_in_executor(
+                    None, 
+                    lambda: self._execute_sync_with_timeout(func, timeout_seconds, *args, **kwargs)
+                )
+        except asyncio.TimeoutError:
+            raise TimeoutError(f"模型 '{model_name}' 执行超时 ({timeout_seconds}秒)")
+    
+    def _execute_sync_with_timeout(self, func: callable, timeout_seconds: int, *args, **kwargs):
+        """同步函数超时执行"""
+        import threading
+        import queue
+        
+        result_queue = queue.Queue()
+        exception_queue = queue.Queue()
+        
+        def worker():
+            try:
+                result = func(*args, **kwargs)
+                result_queue.put(result)
+            except Exception as e:
+                exception_queue.put(e)
+        
+        thread = threading.Thread(target=worker)
+        thread.daemon = True
+        thread.start()
+        thread.join(timeout_seconds)
+        
+        if thread.is_alive():
+            raise TimeoutError(f"同步函数执行超时 ({timeout_seconds}秒)")
+        
+        if not exception_queue.empty():
+            raise exception_queue.get()
+        
+        return result_queue.get()
+    
+    @contextmanager
+    def timeout_context(self, seconds: int):
+        """
+        同步超时上下文管理器
+        
+        Args:
+            seconds: 超时时间（秒）
+        """
+        def timeout_handler(signum, frame):
+            raise TimeoutError(f"操作超时 ({seconds}秒)")
+        
+        # 设置信号处理（仅适用于Unix系统）
+        original_handler = signal.signal(signal.SIGALRM, timeout_handler)
+        signal.alarm(seconds)
+        
+        try:
+            yield
+        finally:
+            # 取消警报
+            signal.alarm(0)
+            signal.signal(signal.SIGALRM, original_handler)
+    
+    async def async_timeout_context(self, seconds: int):
+        """
+        异步超时上下文管理器
+        
+        Args:
+            seconds: 超时时间（秒）
+        """
+        try:
+            await asyncio.wait_for(asyncio.sleep(0), timeout=seconds)
+        except asyncio.TimeoutError:
+            raise TimeoutError(f"异步操作超时 ({seconds}秒)")
+
+
+def timeout(seconds: int = 60):
+    """
+    同步函数超时装饰器
+    
+    Args:
+        seconds: 超时时间（秒）
+    """
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            manager = TimeoutManager()
+            
+            # 在Windows上使用线程实现超时
+            if hasattr(signal, 'SIGALRM'):
+                # Unix系统使用信号
+                with manager.timeout_context(seconds):
+                    return func(*args, **kwargs)
+            else:
+                # Windows系统使用线程
+                result = [None]
+                exception = [None]
+                
+                def target():
+                    try:
+                        result[0] = func(*args, **kwargs)
+                    except Exception as e:
+                        exception[0] = e
+                
+                thread = threading.Thread(target=target)
+                thread.daemon = True
+                thread.start()
+                thread.join(seconds)
+                
+                if thread.is_alive():
+                    raise TimeoutError(f"函数 {func.__name__} 执行超时 ({seconds}秒)")
+                
+                if exception[0]:
+                    raise exception[0]
+                
+                return result[0]
+        
+        return wrapper
+    return decorator
+
+
+def async_timeout(seconds: int = 60):
+    """
+    异步函数超时装饰器
+    
+    Args:
+        seconds: 超时时间（秒）
+    """
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            try:
+                return await asyncio.wait_for(
+                    func(*args, **kwargs), 
+                    timeout=seconds
+                )
+            except asyncio.TimeoutError:
+                raise TimeoutError(f"异步函数 {func.__name__} 执行超时 ({seconds}秒)")
+        
+        return wrapper
+    return decorator
+
+
+class ResourceMonitor:
+    """
+    资源监控器
+    监控内存和CPU使用情况
+    """
+    
+    def __init__(self):
+        self._start_time = None
+        self._peak_memory = 0
+    
+    @contextmanager
+    def monitor_resources(self):
+        """监控资源使用的上下文管理器"""
+        import psutil
+        import os
+        
+        process = psutil.Process(os.getpid())
+        self._start_time = time.time()
+        initial_memory = process.memory_info().rss
+        
+        try:
+            yield
+        finally:
+            current_memory = process.memory_info().rss
+            memory_increase = (current_memory - initial_memory) / 1024 / 1024  # MB
+            
+            execution_time = time.time() - self._start_time
+            
+            # 记录资源使用情况
+            if memory_increase > 100:  # 超过100MB
+                warnings.warn(
+                    f"高内存使用警告: 内存增加 {memory_increase:.2f}MB, "
+                    f"执行时间: {execution_time:.2f}秒"
+                )
+
+
+# 全局超时管理器实例
+global_timeout_manager = TimeoutManager()
+
+
+# 便捷装饰器
+def with_timeout(seconds: int = 60):
+    """便捷超时装饰器，自动选择同步或异步"""
+    def decorator(func):
+        if asyncio.iscoroutinefunction(func):
+            return async_timeout(seconds)(func)
+        else:
+            return timeout(seconds)(func)
+    return decorator
+
+
+def econometric_timeout(function_name: str = None):
+    """
+    计量经济学专用超时装饰器
+    根据函数类型自动设置合适的超时时间
+    """
+    def decorator(func):
+        name = function_name or func.__name__
+        timeout_seconds = global_timeout_manager.get_timeout_for_function(name)
+        
+        if asyncio.iscoroutinefunction(func):
+            return async_timeout(timeout_seconds)(func)
+        else:
+            return timeout(timeout_seconds)(func)
+    
+    return decorator
+
+
+# 导出主要类和函数
+__all__ = [
+    "TimeoutError",
+    "TimeoutManager", 
+    "timeout",
+    "async_timeout",
+    "with_timeout",
+    "econometric_timeout",
+    "ResourceMonitor",
+    "global_timeout_manager"
+]