aiecs 1.0.8__py3-none-any.whl → 1.1.0__py3-none-any.whl

aiecs/tools/langchain_adapter.py

@@ -13,6 +13,9 @@ import logging
 from typing import Any, Dict, List, Optional, Type, Union, get_type_hints
 from pydantic import BaseModel, Field
 
+# Import schema generator
+from aiecs.tools.schema_generator import generate_schema_from_method
+
 try:
     from langchain.tools import BaseTool as LangchainBaseTool
     from langchain.callbacks.manager import CallbackManagerForToolRun, AsyncCallbackManagerForToolRun
@@ -33,24 +36,27 @@ logger = logging.getLogger(__name__)
 class LangchainToolAdapter(LangchainBaseTool):
     """
     Langchain tool adapter for single operation
-    
+
     Wraps one operation method of BaseTool as an independent Langchain tool
     """
-    
+
     # Define class attributes
     name: str = ""
     description: str = ""
-    
+    base_tool_name: str = ""
+    operation_name: str = ""
+    operation_schema: Optional[Type[BaseModel]] = None
+
     def __init__(
-        self, 
+        self,
         base_tool_name: str,
-        operation_name: str, 
+        operation_name: str,
         operation_schema: Optional[Type[BaseModel]] = None,
         description: Optional[str] = None
     ):
         """
         Initialize adapter
-        
+
         Args:
             base_tool_name: Original tool name
             operation_name: Operation name
@@ -58,56 +64,55 @@ class LangchainToolAdapter(LangchainBaseTool):
             description: Tool description
         """
         # Construct tool name and description
-        self.name = f"{base_tool_name}_{operation_name}"
-        self.description = description or f"Execute {operation_name} operation from {base_tool_name} tool"
-        
-        # Store tool information (use self.__dict__ to set directly to avoid pydantic validation)
-        self.__dict__['base_tool_name'] = base_tool_name
-        self.__dict__['operation_name'] = operation_name
-        self.__dict__['operation_schema'] = operation_schema
-        
-        # Set parameter Schema
-        if operation_schema:
-            self.args_schema = operation_schema
-        
-        super().__init__()
+        tool_name = f"{base_tool_name}_{operation_name}"
+        tool_description = description or f"Execute {operation_name} operation from {base_tool_name} tool"
+
+        # Initialize parent class with all required fields
+        super().__init__(
+            name=tool_name,
+            description=tool_description,
+            base_tool_name=base_tool_name,
+            operation_name=operation_name,
+            operation_schema=operation_schema,
+            args_schema=operation_schema
+        )
     
     def _run(
-        self, 
-        run_manager: Optional[CallbackManagerForToolRun] = None, 
+        self,
+        run_manager: Optional[CallbackManagerForToolRun] = None,
         **kwargs: Any
     ) -> Any:
         """Execute operation synchronously"""
         try:
             # Get original tool instance
-            base_tool = get_tool(self.__dict__['base_tool_name'])
-            
+            base_tool = get_tool(self.base_tool_name)
+
             # Execute operation
-            result = base_tool.run(self.__dict__['operation_name'], **kwargs)
-            
+            result = base_tool.run(self.operation_name, **kwargs)
+
             logger.info(f"Successfully executed {self.name} with result type: {type(result)}")
             return result
-            
+
         except Exception as e:
             logger.error(f"Error executing {self.name}: {str(e)}")
             raise
-    
+
     async def _arun(
-        self, 
+        self,
         run_manager: Optional[AsyncCallbackManagerForToolRun] = None,
         **kwargs: Any
     ) -> Any:
         """Execute operation asynchronously"""
         try:
             # Get original tool instance
-            base_tool = get_tool(self.__dict__['base_tool_name'])
-            
+            base_tool = get_tool(self.base_tool_name)
+
             # Execute asynchronous operation
-            result = await base_tool.run_async(self.__dict__['operation_name'], **kwargs)
-            
+            result = await base_tool.run_async(self.operation_name, **kwargs)
+
             logger.info(f"Successfully executed {self.name} async with result type: {type(result)}")
             return result
-            
+
         except Exception as e:
             logger.error(f"Error executing {self.name} async: {str(e)}")
             raise
@@ -121,47 +126,90 @@ class ToolRegistry:
     def discover_operations(self, base_tool_class: Type[BaseTool]) -> List[Dict[str, Any]]:
         """
         Discover all operation methods and Schemas of BaseTool class
-        
+
         Args:
             base_tool_class: BaseTool subclass
-            
+
         Returns:
             List of operation information, including method names, Schemas, descriptions, etc.
         """
         operations = []
-        
+
         # Get all Schema classes
+        # Build a mapping from normalized names to Schema classes
+        # Check both class-level and module-level schemas
         schemas = {}
+
+        # 1. Check class-level schemas (e.g., ChartTool)
         for attr_name in dir(base_tool_class):
             attr = getattr(base_tool_class, attr_name)
             if isinstance(attr, type) and issubclass(attr, BaseModel) and attr.__name__.endswith('Schema'):
-                op_name = attr.__name__.replace('Schema', '').lower()
-                schemas[op_name] = attr
-        
+                # Normalize: remove 'Schema' suffix, convert to lowercase, remove underscores
+                schema_base_name = attr.__name__.replace('Schema', '')
+                normalized_name = schema_base_name.replace('_', '').lower()
+                schemas[normalized_name] = attr
+                logger.debug(f"Found class-level schema {attr.__name__} -> normalized: {normalized_name}")
+
+        # 2. Check module-level schemas (e.g., ImageTool)
+        tool_module = inspect.getmodule(base_tool_class)
+        if tool_module:
+            for attr_name in dir(tool_module):
+                if attr_name.startswith('_'):
+                    continue
+                attr = getattr(tool_module, attr_name)
+                if isinstance(attr, type) and issubclass(attr, BaseModel) and attr.__name__.endswith('Schema'):
+                    # Skip if already found at class level
+                    schema_base_name = attr.__name__.replace('Schema', '')
+                    normalized_name = schema_base_name.replace('_', '').lower()
+                    if normalized_name not in schemas:
+                        schemas[normalized_name] = attr
+                        logger.debug(f"Found module-level schema {attr.__name__} -> normalized: {normalized_name}")
+
         # Get all public methods
         for method_name in dir(base_tool_class):
             if method_name.startswith('_'):
                 continue
-                
+
             method = getattr(base_tool_class, method_name)
             if not callable(method):
                 continue
-                
-            # Skip base class methods
+
+            # Skip base class methods and Schema classes themselves
             if method_name in ['run', 'run_async', 'run_batch']:
                 continue
-            
+
+            # Skip if it's a class (like Config or Schema classes)
+            if isinstance(method, type):
+                continue
+
+            # Normalize method name: remove underscores and convert to lowercase
+            normalized_method_name = method_name.replace('_', '').lower()
+
+            # Try to find matching schema
+            matching_schema = schemas.get(normalized_method_name)
+
+            if matching_schema:
+                logger.debug(f"Matched method {method_name} with manual schema {matching_schema.__name__}")
+            else:
+                # Auto-generate schema if not found
+                auto_schema = generate_schema_from_method(method, method_name)
+                if auto_schema:
+                    matching_schema = auto_schema
+                    logger.debug(f"Auto-generated schema for method {method_name}: {auto_schema.__name__}")
+                else:
+                    logger.debug(f"No schema found or generated for method {method_name}")
+
             # Get method information
             operation_info = {
                 'name': method_name,
                 'method': method,
-                'schema': schemas.get(method_name),
+                'schema': matching_schema,
                 'description': inspect.getdoc(method) or f"Execute {method_name} operation",
                 'is_async': inspect.iscoroutinefunction(method)
             }
-            
+
             operations.append(operation_info)
-        
+
         return operations
     
     def _extract_description(self, method, base_tool_name: str, operation_name: str, schema: Optional[Type[BaseModel]] = None) -> str:
@@ -255,20 +303,23 @@ class ToolRegistry:
     def create_all_langchain_tools(self) -> List[LangchainToolAdapter]:
         """
         Create Langchain adapters for all registered BaseTools
-        
+
         Returns:
             List of all Langchain tool adapters
         """
         all_tools = []
-        
-        for tool_name in list_tools():
+
+        # list_tools() returns a list of dicts, extract tool names
+        tool_infos = list_tools()
+        for tool_info in tool_infos:
+            tool_name = tool_info['name']
             try:
                 tools = self.create_langchain_tools(tool_name)
                 all_tools.extend(tools)
             except Exception as e:
                 logger.error(f"Failed to create Langchain tools for {tool_name}: {e}")
-        
-        logger.info(f"Created total {len(all_tools)} Langchain tools from {len(list_tools())} base tools")
+
+        logger.info(f"Created total {len(all_tools)} Langchain tools from {len(tool_infos)} base tools")
         return all_tools
     
     def get_tool(self, name: str) -> Optional[LangchainToolAdapter]:

aiecs/tools/schema_generator.py

@@ -0,0 +1,265 @@
+"""
+自动 Schema 生成工具
+
+从方法签名和类型注解自动生成 Pydantic Schema
+"""
+
+import inspect
+import logging
+from typing import Any, Dict, List, Optional, Type, get_type_hints, Union
+from pydantic import BaseModel, Field, create_model, ConfigDict
+
+logger = logging.getLogger(__name__)
+
+
+def _normalize_type(param_type: Type) -> Type:
+    """
+    标准化类型，处理不支持的类型
+
+    将 pandas.DataFrame 等复杂类型映射为 Any
+    """
+    # 获取类型名称
+    type_name = getattr(param_type, '__name__', str(param_type))
+
+    # 检查是否是 pandas 类型
+    if 'DataFrame' in type_name or 'Series' in type_name:
+        return Any
+
+    return param_type
+
+
+def _extract_param_description_from_docstring(docstring: str, param_name: str) -> Optional[str]:
+    """
+    从文档字符串中提取参数描述
+
+    支持格式:
+    - Google style: Args: param_name: description
+    - NumPy style: Parameters: param_name : type description
+    """
+    if not docstring:
+        return None
+
+    lines = docstring.split('\n')
+    in_args_section = False
+    current_param = None
+    description_lines = []
+
+    for line in lines:
+        stripped = line.strip()
+
+        # 检测 Args/Parameters 部分
+        if stripped in ['Args:', 'Arguments:', 'Parameters:']:
+            in_args_section = True
+            continue
+
+        # 检测结束
+        if in_args_section and stripped in ['Returns:', 'Raises:', 'Yields:', 'Examples:', 'Note:', 'Notes:']:
+            break
+
+        if in_args_section:
+            # Google style: param_name: description 或 param_name (type): description
+            if ':' in stripped and not stripped.startswith(' '):
+                # 保存之前的参数
+                if current_param == param_name and description_lines:
+                    return ' '.join(description_lines).strip()
+
+                # 解析新参数
+                parts = stripped.split(':', 1)
+                if len(parts) == 2:
+                    # 移除可能的类型注解 (type)
+                    param_part = parts[0].strip()
+                    if '(' in param_part:
+                        param_part = param_part.split('(')[0].strip()
+
+                    current_param = param_part
+                    description_lines = [parts[1].strip()]
+            elif current_param and stripped:
+                # 继续描述
+                description_lines.append(stripped)
+
+    # 检查最后一个参数
+    if current_param == param_name and description_lines:
+        return ' '.join(description_lines).strip()
+
+    return None
+
+
+def generate_schema_from_method(
+    method: callable,
+    method_name: str,
+    base_class: Type[BaseModel] = BaseModel
+) -> Optional[Type[BaseModel]]:
+    """
+    从方法签名自动生成 Pydantic Schema
+
+    Args:
+        method: 要生成 Schema 的方法
+        method_name: 方法名称
+        base_class: Schema 基类
+
+    Returns:
+        生成的 Pydantic Schema 类，如果无法生成则返回 None
+    """
+    try:
+        # 获取方法签名
+        sig = inspect.signature(method)
+
+        # 获取类型注解
+        try:
+            type_hints = get_type_hints(method)
+        except Exception as e:
+            logger.debug(f"Failed to get type hints for {method_name}: {e}")
+            type_hints = {}
+
+        # 获取文档字符串
+        docstring = inspect.getdoc(method) or f"Execute {method_name} operation"
+
+        # 提取简短描述（第一行）
+        first_line = docstring.split('\n')[0].strip()
+        schema_description = first_line if first_line else f"Execute {method_name} operation"
+
+        # 构建字段定义
+        field_definitions = {}
+
+        for param_name, param in sig.parameters.items():
+            # 跳过 self 参数
+            if param_name == 'self':
+                continue
+
+            # 获取参数类型并标准化
+            param_type = type_hints.get(param_name, Any)
+            param_type = _normalize_type(param_type)
+
+            # 获取默认值
+            has_default = param.default != inspect.Parameter.empty
+            default_value = param.default if has_default else ...
+
+            # 从文档字符串提取参数描述
+            field_description = _extract_param_description_from_docstring(docstring, param_name)
+            if not field_description:
+                field_description = f"Parameter {param_name}"
+
+            # 创建 Field
+            if has_default:
+                if default_value is None:
+                    # Optional 参数
+                    field_definitions[param_name] = (
+                        param_type,
+                        Field(default=None, description=field_description)
+                    )
+                else:
+                    field_definitions[param_name] = (
+                        param_type,
+                        Field(default=default_value, description=field_description)
+                    )
+            else:
+                # 必需参数
+                field_definitions[param_name] = (
+                    param_type,
+                    Field(description=field_description)
+                )
+
+        # 如果没有参数（除了 self），返回 None
+        if not field_definitions:
+            logger.debug(f"No parameters found for {method_name}, skipping schema generation")
+            return None
+
+        # 生成 Schema 类名
+        schema_name = f"{method_name.title().replace('_', '')}Schema"
+
+        # 创建 Schema 类，允许任意类型
+        schema_class = create_model(
+            schema_name,
+            __base__=base_class,
+            __doc__=schema_description,
+            __config__=ConfigDict(arbitrary_types_allowed=True),
+            **field_definitions
+        )
+
+        logger.debug(f"Generated schema {schema_name} for method {method_name}")
+        return schema_class
+
+    except Exception as e:
+        logger.warning(f"Failed to generate schema for {method_name}: {e}")
+        return None
+
+
+def generate_schemas_for_tool(tool_class: Type) -> Dict[str, Type[BaseModel]]:
+    """
+    为工具类的所有方法生成 Schema
+    
+    Args:
+        tool_class: 工具类
+        
+    Returns:
+        方法名到 Schema 类的映射
+    """
+    schemas = {}
+    
+    for method_name in dir(tool_class):
+        # 跳过私有方法和特殊方法
+        if method_name.startswith('_'):
+            continue
+        
+        # 跳过基类方法
+        if method_name in ['run', 'run_async', 'run_batch']:
+            continue
+        
+        method = getattr(tool_class, method_name)
+        
+        # 跳过非方法属性
+        if not callable(method):
+            continue
+        
+        # 跳过类（如 Config, Schema 等）
+        if isinstance(method, type):
+            continue
+        
+        # 生成 Schema
+        schema = generate_schema_from_method(method, method_name)
+        
+        if schema:
+            # 标准化方法名（移除下划线，转小写）
+            normalized_name = method_name.replace('_', '').lower()
+            schemas[normalized_name] = schema
+            logger.info(f"Generated schema for {method_name}")
+    
+    return schemas
+
+
+
+
+
+# 使用示例
+if __name__ == '__main__':
+    import sys
+    sys.path.insert(0, '/home/coder1/python-middleware-dev')
+
+    from aiecs.tools import discover_tools, TOOL_CLASSES
+
+    # 配置日志
+    logging.basicConfig(level=logging.INFO)
+
+    # 发现工具
+    discover_tools()
+
+    # 为 PandasTool 生成 Schema
+    print("为 PandasTool 生成 Schema:")
+    print("=" * 80)
+
+    pandas_tool = TOOL_CLASSES['pandas']
+    schemas = generate_schemas_for_tool(pandas_tool)
+
+    print(f"\n生成了 {len(schemas)} 个 Schema:\n")
+
+    # 显示前3个示例
+    for method_name, schema in list(schemas.items())[:3]:
+        print(f"{schema.__name__}:")
+        print(f"  描述: {schema.__doc__}")
+        print(f"  字段:")
+        for field_name, field_info in schema.model_fields.items():
+            required = "必需" if field_info.is_required() else "可选"
+            default = f" (默认: {field_info.default})" if not field_info.is_required() and field_info.default is not None else ""
+            print(f"    - {field_name}: {field_info.description} [{required}]{default}")
+        print()
+

aiecs/tools/task_tools/image_tool.py

@@ -214,7 +214,7 @@ class ImageTool(BaseTool):
         """Clean up Tesseract processes on destruction."""
         self._tesseract_manager.cleanup()
 
-    def update_settings(self, config: Dict):
+    def update_settings(self, config: Dict) -> None:
         """
         Update configuration settings dynamically.
 

aiecs/tools/task_tools/office_tool.py

@@ -1,11 +1,20 @@
 import os
 import logging
+import warnings
 from typing import List, Dict, Optional, Any
 
 import pandas as pd
 import pdfplumber
 import pytesseract
 from PIL import Image
+
+# Configure Tika log path to user-writable directory before importing
+os.environ['TIKA_LOG_PATH'] = os.path.expanduser('~/.cache/tika')
+os.makedirs(os.path.expanduser('~/.cache/tika'), exist_ok=True)
+
+# Suppress pkg_resources deprecation warning from tika
+warnings.filterwarnings('ignore', category=UserWarning, module='tika')
+
 from tika import parser
 from docx import Document as DocxDocument
 from docx.shared import Pt

aiecs/tools/task_tools/scraper_tool.py

@@ -46,7 +46,7 @@ class RenderEngine(str, Enum):
     PLAYWRIGHT = "playwright"
 
 # Global settings
-class ScraperSettings(BaseSettings):
+class ScraperSettings(BaseModel):
     """
     Configuration for ScraperTool.
 

{aiecs-1.0.8.dist-info → aiecs-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiecs
-Version: 1.0.8
+Version: 1.1.0
 Summary: AI Execute Services - A middleware framework for AI-powered task execution and tool orchestration
 Author-email: AIECS Team <iretbl@gmail.com>
 License-Expression: MIT