aigroup-econ-mcp 0.4.0__py3-none-any.whl → 1.3.3__py3-none-any.whl

aigroup_econ_mcp/server_with_file_support.py

@@ -1,259 +0,0 @@
-"""
-AIGroup 计量经济学 MCP 服务器 - 支持CSV文件路径输入
-使用最新的MCP特性提供专业计量经济学分析工具
-"""
-
-from typing import List, Dict, Any, Optional, Annotated, Union
-from collections.abc import AsyncIterator
-from contextlib import asynccontextmanager
-from dataclasses import dataclass
-import json
-from pathlib import Path
-
-import pandas as pd
-import numpy as np
-import statsmodels.api as sm
-from statsmodels.tsa import stattools
-from scipy import stats
-from pydantic import BaseModel, Field
-
-from mcp.server.fastmcp import FastMCP, Context
-from mcp.server.session import ServerSession
-from mcp.types import CallToolResult, TextContent
-
-
-# 数据模型定义
-class DescriptiveStatsResult(BaseModel):
-    """描述性统计结果"""
-    count: int = Field(description="样本数量")
-    mean: float = Field(description="均值")
-    std: float = Field(description="标准差")
-    min: float = Field(description="最小值")
-    max: float = Field(description="最大值")
-    median: float = Field(description="中位数")
-    skewness: float = Field(description="偏度")
-    kurtosis: float = Field(description="峰度")
-
-
-# 应用上下文
-@dataclass
-class AppContext:
-    """应用上下文，包含共享资源"""
-    config: Dict[str, Any]
-    version: str = "0.2.0"
-
-
-@asynccontextmanager
-async def lifespan(server: FastMCP) -> AsyncIterator[AppContext]:
-    """服务器生命周期管理"""
-    config = {
-        "max_sample_size": 10000,
-        "default_significance_level": 0.05,
-        "supported_tests": ["t_test", "f_test", "chi_square", "adf"],
-        "data_types": ["cross_section", "time_series", "panel"]
-    }
-    try:
-        yield AppContext(config=config, version="0.2.0")
-    finally:
-        pass
-
-
-# 创建MCP服务器实例
-mcp = FastMCP(
-    name="aigroup-econ-mcp",
-    instructions="Econometrics MCP Server with CSV file path support",
-    lifespan=lifespan
-)
-
-
-# 辅助函数：加载CSV文件
-async def load_data_from_path(file_path: str, ctx: Context) -> Dict[str, List[float]]:
-    """从CSV文件路径加载数据"""
-    await ctx.info(f"正在从文件加载数据: {file_path}")
-    
-    try:
-        # 读取CSV文件
-        df = pd.read_csv(file_path)
-        
-        # 转换为字典格式
-        data = {col: df[col].tolist() for col in df.columns}
-        
-        await ctx.info(f"✅ 文件加载成功：{len(df.columns)}个变量，{len(df)}个观测")
-        return data
-        
-    except FileNotFoundError:
-        raise ValueError(f"文件不存在: {file_path}")
-    except Exception as e:
-        raise ValueError(f"文件读取失败: {str(e)}")
-
-
-@mcp.tool()
-async def descriptive_statistics(
-    ctx: Context[ServerSession, AppContext],
-    data: Annotated[
-        Union[Dict[str, List[float]], str],
-        Field(
-            description="""数据输入，支持两种格式：
-
-📊 格式1：数据字典
-{
-    "GDP增长率": [3.2, 2.8, 3.5, 2.9],
-    "通货膨胀率": [2.1, 2.3, 1.9, 2.4],
-    "失业率": [4.5, 4.2, 4.0, 4.3]
-}
-
-📁 格式2：CSV文件路径（推荐）
-"d:/data/economic_data.csv"
-或
-"./test_data.csv"
-
-CSV文件要求：
-- 第一行为变量名（表头）
-- 后续行为数值数据
-- 所有列必须为数值类型"""
-        )
-    ]
-) -> CallToolResult:
-    """计算描述性统计量
-    
-    📊 功能说明：
-    对输入数据进行全面的描述性统计分析，包括集中趋势、离散程度、分布形状等指标。
-    
-    💡 使用场景：
-    - 初步了解数据的分布特征
-    - 检查数据质量和异常值
-    - 为后续建模提供基础信息
-    """
-    try:
-        # 检测输入类型并加载数据
-        if isinstance(data, str):
-            # 文件路径输入
-            data_dict = await load_data_from_path(data, ctx)
-        else:
-            # 字典输入
-            data_dict = data
-        
-        await ctx.info(f"开始计算描述性统计，处理 {len(data_dict)} 个变量")
-        
-        # 数据验证
-        if not data_dict:
-            raise ValueError("数据不能为空")
-        
-        df = pd.DataFrame(data_dict)
-        
-        # 基础统计量
-        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()
-        )
-        
-        # 计算相关系数矩阵
-        correlation_matrix = df.corr().round(4)
-        
-        await ctx.info(f"描述性统计计算完成，样本大小: {len(df)}")
-        
-        return CallToolResult(
-            content=[
-                TextContent(
-                    type="text",
-                    text=f"描述性统计结果：\n"
-                         f"样本数: {result.count}\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()}"
-                )
-            ],
-            structuredContent=result.model_dump()
-        )
-        
-    except Exception as e:
-        await ctx.error(f"计算描述性统计时出错: {str(e)}")
-        return CallToolResult(
-            content=[TextContent(type="text", text=f"错误: {str(e)}")],
-            isError=True
-        )
-
-
-@mcp.tool()
-async def correlation_analysis(
-    ctx: Context[ServerSession, AppContext],
-    data: Annotated[
-        Union[Dict[str, List[float]], str],
-        Field(
-            description="""数据输入，支持两种格式：
-
-📊 格式1：数据字典
-{
-    "销售额": [12000, 13500, 11800, 14200],
-    "广告支出": [800, 900, 750, 1000],
-    "价格": [99, 95, 102, 98]
-}
-
-📁 格式2：CSV文件路径
-"d:/data/marketing_data.csv"
-
-要求：
-- 至少包含2个变量
-- 所有变量的数据点数量必须相同"""
-        )
-    ],
-    method: Annotated[
-        str,
-        Field(
-            default="pearson",
-            description="相关系数类型：pearson/spearman/kendall"
-        )
-    ] = "pearson"
-) -> CallToolResult:
-    """变量间相关性分析"""
-    try:
-        # 检测输入类型并加载数据
-        if isinstance(data, str):
-            data_dict = await load_data_from_path(data, ctx)
-        else:
-            data_dict = data
-        
-        await ctx.info(f"开始相关性分析: {method}")
-        
-        # 数据验证
-        if not data_dict:
-            raise ValueError("数据不能为空")
-        if len(data_dict) < 2:
-            raise ValueError("至少需要2个变量进行相关性分析")
-        
-        df = pd.DataFrame(data_dict)
-        correlation_matrix = df.corr(method=method)
-        
-        await ctx.info("相关性分析完成")
-        
-        return CallToolResult(
-            content=[
-                TextContent(
-                    type="text",
-                    text=f"{method.title()}相关系数矩阵：\n{correlation_matrix.round(4).to_string()}"
-                )
-            ]
-        )
-        
-    except Exception as e:
-        await ctx.error(f"相关性分析出错: {str(e)}")
-        return CallToolResult(
-            content=[TextContent(type="text", text=f"错误: {str(e)}")],
-            isError=True
-        )
-
-
-def create_mcp_server() -> FastMCP:
-    """创建并返回MCP服务器实例"""
-    return mcp

aigroup_econ_mcp/tools/decorators.py

@@ -1,178 +0,0 @@
-"""
-工具装饰器模块
-提供自动文件输入处理、错误处理等功能
-"""
-
-from typing import Callable, Optional, Dict, Any, List
-from functools import wraps
-from mcp.server.session import ServerSession
-from mcp.server.fastmcp import Context
-from mcp.types import CallToolResult, TextContent
-
-from .file_parser import FileParser
-
-
-def with_file_input(tool_type: str):
-    """
-    为工具函数添加文件输入支持的装饰器
-    
-    支持两种输入方式：
-    1. file_path: CSV/JSON文件路径
-    2. file_content: 文件内容字符串
-    
-    Args:
-        tool_type: 工具类型 ('single_var', 'multi_var_dict', 'regression', 'panel', 'time_series')
-    
-    使用示例:
-        @with_file_input('regression')
-        async def my_tool(ctx, y_data=None, x_data=None, file_path=None, file_content=None, file_format='auto', **kwargs):
-            # 如果提供了file_path或file_content，数据会被自动填充
-            pass
-    """
-    def decorator(func: Callable) -> Callable:
-        @wraps(func)
-        async def wrapper(*args, **kwargs):
-            # 提取上下文和文件参数
-            ctx = args[0] if args else kwargs.get('ctx')
-            file_path = kwargs.get('file_path')
-            file_content = kwargs.get('file_content')
-            file_format = kwargs.get('file_format', 'auto')
-            
-            # 优先处理file_path
-            if file_path:
-                try:
-                    await ctx.info(f"检测到文件路径输入: {file_path}")
-                    
-                    # 从文件路径解析
-                    parsed = FileParser.parse_file_path(file_path, file_format)
-                    
-                    await ctx.info(
-                        f"文件解析成功：{parsed['n_variables']}个变量，"
-                        f"{parsed['n_observations']}个观测"
-                    )
-                    
-                    # 转换为工具格式
-                    converted = FileParser.convert_to_tool_format(parsed, tool_type)
-                    
-                    # 更新kwargs
-                    kwargs.update(converted)
-                    
-                    await ctx.info(f"数据已转换为{tool_type}格式")
-                    
-                except Exception as e:
-                    await ctx.error(f"文件解析失败: {str(e)}")
-                    return CallToolResult(
-                        content=[TextContent(type="text", text=f"文件解析错误: {str(e)}")],
-                        isError=True
-                    )
-            
-            # 如果没有file_path但有file_content，处理文件内容
-            elif file_content:
-                try:
-                    await ctx.info("检测到文件内容输入，开始解析...")
-                    
-                    # 解析文件内容
-                    parsed = FileParser.parse_file_content(file_content, file_format)
-                    
-                    await ctx.info(
-                        f"文件解析成功：{parsed['n_variables']}个变量，"
-                        f"{parsed['n_observations']}个观测"
-                    )
-                    
-                    # 转换为工具格式
-                    converted = FileParser.convert_to_tool_format(parsed, tool_type)
-                    
-                    # 更新kwargs
-                    kwargs.update(converted)
-                    
-                    await ctx.info(f"数据已转换为{tool_type}格式")
-                    
-                except Exception as e:
-                    await ctx.error(f"文件解析失败: {str(e)}")
-                    return CallToolResult(
-                        content=[TextContent(type="text", text=f"文件解析错误: {str(e)}")],
-                        isError=True
-                    )
-            
-            # 调用原函数
-            return await func(*args, **kwargs)
-        
-        return wrapper
-    return decorator
-
-
-def with_error_handling(func: Callable) -> Callable:
-    """
-    为工具函数添加统一错误处理的装饰器
-    """
-    @wraps(func)
-    async def wrapper(*args, **kwargs):
-        ctx = args[0] if args else kwargs.get('ctx')
-        tool_name = func.__name__
-        
-        try:
-            return await func(*args, **kwargs)
-        except Exception as e:
-            await ctx.error(f"{tool_name}执行出错: {str(e)}")
-            return CallToolResult(
-                content=[TextContent(type="text", text=f"错误: {str(e)}")],
-                isError=True
-            )
-    
-    return wrapper
-
-
-def with_logging(func: Callable) -> Callable:
-    """
-    为工具函数添加日志记录的装饰器
-    """
-    @wraps(func)
-    async def wrapper(*args, **kwargs):
-        ctx = args[0] if args else kwargs.get('ctx')
-        tool_name = func.__name__
-        
-        await ctx.info(f"开始执行 {tool_name}")
-        result = await func(*args, **kwargs)
-        await ctx.info(f"{tool_name} 执行完成")
-        
-        return result
-    
-    return wrapper
-
-
-def econometric_tool(
-    tool_type: str,
-    with_file_support: bool = True,
-    with_error_handling: bool = True,
-    with_logging: bool = True
-):
-    """
-    组合装饰器：为计量经济学工具添加所有标准功能
-    
-    Args:
-        tool_type: 工具类型
-        with_file_support: 是否启用文件输入支持
-        with_error_handling: 是否启用错误处理
-        with_logging: 是否启用日志记录
-    
-    使用示例:
-        @econometric_tool('regression')
-        async def ols_regression(ctx, y_data=None, x_data=None, **kwargs):
-            # 只需要编写核心业务逻辑
-            pass
-    """
-    def decorator(func: Callable) -> Callable:
-        wrapped = func
-        
-        if with_error_handling:
-            wrapped = globals()['with_error_handling'](wrapped)
-        
-        if with_file_support:
-            wrapped = with_file_input(tool_type)(wrapped)
-        
-        if with_logging:
-            wrapped = globals()['with_logging'](wrapped)
-        
-        return wrapped
-    
-    return decorator

aigroup_econ_mcp/tools/file_input_handler.py

@@ -1,268 +0,0 @@
-"""
-文件输入处理组件
-提供统一的文件输入处理接口，支持所有工具
-"""
-
-from typing import Dict, List, Any, Optional, Callable
-from functools import wraps
-from .file_parser import FileParser
-
-
-class FileInputHandler:
-    """
-    文件输入处理组件
-    
-    使用组件模式，为任何工具函数添加文件输入支持
-    """
-    
-    @staticmethod
-    def process_input(
-        file_content: Optional[str],
-        file_format: str,
-        tool_type: str,
-        data_params: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """
-        处理文件输入并转换为工具参数
-        
-        Args:
-            file_content: 文件内容
-            file_format: 文件格式
-            tool_type: 工具类型
-            data_params: 当前数据参数
-        
-        Returns:
-            更新后的参数字典
-        """
-        # 如果没有文件输入，直接返回原参数
-        if file_content is None:
-            return data_params
-        
-        # 解析文件
-        parsed = FileParser.parse_file_content(file_content, file_format)
-        
-        # 转换为工具格式
-        converted = FileParser.convert_to_tool_format(parsed, tool_type)
-        
-        # 合并参数（文件数据优先）
-        result = {**data_params, **converted}
-        
-        return result
-    
-    @staticmethod
-    def with_file_support(tool_type: str):
-        """
-        装饰器：为工具函数添加文件输入支持
-        
-        Args:
-            tool_type: 工具类型（single_var, multi_var_dict, regression, panel等）
-        
-        Returns:
-            装饰后的函数
-        
-        使用示例：
-            @FileInputHandler.with_file_support('regression')
-            async def my_regression_tool(y_data, x_data, file_content=None, file_format='auto'):
-                # 函数会自动处理file_content并填充y_data和x_data
-                pass
-        """
-        def decorator(func: Callable) -> Callable:
-            @wraps(func)
-            async def wrapper(*args, **kwargs):
-                # 提取文件相关参数
-                file_content = kwargs.get('file_content')
-                file_format = kwargs.get('file_format', 'auto')
-                
-                if file_content is not None:
-                    # 处理文件输入
-                    processed = FileInputHandler.process_input(
-                        file_content=file_content,
-                        file_format=file_format,
-                        tool_type=tool_type,
-                        data_params=kwargs
-                    )
-                    
-                    # 更新kwargs
-                    kwargs.update(processed)
-                
-                # 调用原函数
-                return await func(*args, **kwargs)
-            
-            return wrapper
-        return decorator
-
-
-class FileInputMixin:
-    """
-    文件输入混入类
-    
-    为类提供文件输入处理能力
-    """
-    
-    def parse_file_input(
-        self,
-        file_content: Optional[str],
-        file_format: str = "auto"
-    ) -> Optional[Dict[str, Any]]:
-        """解析文件输入"""
-        if file_content is None:
-            return None
-        return FileParser.parse_file_content(file_content, file_format)
-    
-    def convert_for_tool(
-        self,
-        parsed_data: Dict[str, Any],
-        tool_type: str
-    ) -> Dict[str, Any]:
-        """转换为工具格式"""
-        return FileParser.convert_to_tool_format(parsed_data, tool_type)
-    
-    def get_recommendations(
-        self,
-        parsed_data: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """获取工具推荐"""
-        return FileParser.auto_detect_tool_params(parsed_data)
-
-
-def create_file_params(
-    description: str = "CSV或JSON文件内容"
-) -> Dict[str, Any]:
-    """
-    创建标准的文件输入参数定义
-    
-    Args:
-        description: 参数描述
-    
-    Returns:
-        参数定义字典，可直接用于Field()
-    """
-    return {
-        "file_content": {
-            "default": None,
-            "description": f"""{description}
-            
-📁 支持格式：
-- CSV: 带表头的列数据，自动检测分隔符
-- JSON: {{"变量名": [数据], ...}} 或 [{{"变量1": 值, ...}}, ...]
-
-💡 使用方式：
-- 提供文件内容字符串（可以是base64编码）
-- 系统会自动解析并识别变量
-- 优先使用file_content，如果提供则忽略其他数据参数"""
-        },
-        "file_format": {
-            "default": "auto",
-            "description": """文件格式
-            
-可选值：
-- "auto": 自动检测（默认）
-- "csv": CSV格式
-- "json": JSON格式"""
-        }
-    }
-
-
-class UnifiedFileInput:
-    """
-    统一文件输入接口
-    
-    所有工具通过此类统一处理文件输入
-    """
-    
-    @staticmethod
-    async def handle(
-        ctx: Any,
-        file_content: Optional[str],
-        file_format: str,
-        tool_type: str,
-        original_params: Dict[str, Any]
-    ) -> Dict[str, Any]:
-        """
-        统一处理文件输入
-        
-        Args:
-            ctx: MCP上下文
-            file_content: 文件内容
-            file_format: 文件格式
-            tool_type: 工具类型
-            original_params: 原始参数
-        
-        Returns:
-            处理后的参数
-        """
-        if file_content is None:
-            return original_params
-        
-        try:
-            # 记录日志
-            await ctx.info("检测到文件输入，开始解析...")
-            
-            # 解析文件
-            parsed = FileParser.parse_file_content(file_content, file_format)
-            
-            # 记录解析结果
-            await ctx.info(
-                f"文件解析成功：{parsed['n_variables']}个变量，"
-                f"{parsed['n_observations']}个观测，"
-                f"数据类型={parsed['data_type']}"
-            )
-            
-            # 转换为工具格式
-            converted = FileParser.convert_to_tool_format(parsed, tool_type)
-            
-            # 合并参数
-            result = {**original_params}
-            result.update(converted)
-            
-            # 记录转换结果
-            if tool_type == 'regression':
-                await ctx.info(
-                    f"数据已转换：因变量={converted.get('y_variable')}，"
-                    f"自变量={converted.get('feature_names')}"
-                )
-            elif tool_type == 'panel':
-                await ctx.info(
-                    f"面板数据已识别：{len(set(converted.get('entity_ids', [])))}个实体，"
-                    f"{len(set(converted.get('time_periods', [])))}个时间点"
-                )
-            else:
-                await ctx.info(f"数据已转换为{tool_type}格式")
-            
-            return result
-            
-        except Exception as e:
-            await ctx.error(f"文件解析失败: {str(e)}")
-            raise ValueError(f"文件解析失败: {str(e)}")
-
-
-# 便捷函数
-async def process_file_for_tool(
-    ctx: Any,
-    file_content: Optional[str],
-    file_format: str,
-    tool_type: str,
-    **kwargs
-) -> Dict[str, Any]:
-    """
-    为工具处理文件输入的便捷函数
-    
-    使用示例：
-        params = await process_file_for_tool(
-            ctx=ctx,
-            file_content=file_content,
-            file_format=file_format,
-            tool_type='regression',
-            y_data=y_data,
-            x_data=x_data,
-            feature_names=feature_names
-        )
-        # params 现在包含处理后的所有参数
-    """
-    return await UnifiedFileInput.handle(
-        ctx=ctx,
-        file_content=file_content,
-        file_format=file_format,
-        tool_type=tool_type,
-        original_params=kwargs
-    )