aiecs 1.0.0__py3-none-any.whl

aiecs/scripts/run_weasel_patch.sh

@@ -0,0 +1,41 @@
+#!/bin/bash
+
+# Script to run the weasel library patch using poetry
+# This ensures we're working within the correct virtual environment
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+
+echo "🔧 Running Weasel Library Patch via Poetry"
+echo "=========================================="
+echo "Project directory: $PROJECT_DIR"
+echo ""
+
+# Change to project directory
+cd "$PROJECT_DIR"
+
+# Check if pyproject.toml exists
+if [ ! -f "pyproject.toml" ]; then
+    echo "❌ Error: pyproject.toml not found. Please run this script from the python-middleware directory"
+    exit 1
+fi
+
+# Check if poetry is available
+if ! command -v poetry &> /dev/null; then
+    echo "❌ Error: Poetry is not installed or not in PATH"
+    echo "Please install poetry first: https://python-poetry.org/docs/#installation"
+    exit 1
+fi
+
+# Run the Python patch script using poetry
+echo "🚀 Running patch script with poetry..."
+poetry run python3 scripts/fix_weasel_validator.py
+
+echo ""
+echo "🎉 Patch execution completed!"
+echo ""
+echo "Next steps:"
+echo "1. Try running your tests again with: poetry run pytest"
+echo "2. If the issue persists, you may need to restart your development environment"

aiecs/scripts/setup_nlp_data.sh

@@ -0,0 +1,217 @@
+#!/bin/bash
+# Setup NLP Data for AIECS ClassifierTool
+# This script downloads required NLTK and spaCy data packages
+
+set -e  # Exit on any error
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../.." && pwd)"
+
+echo "=================================================="
+echo "AIECS NLP Data Setup"
+echo "=================================================="
+echo "This script will download required NLP data for:"
+echo "  - NLTK stopwords corpus"
+echo "  - spaCy English model (en_core_web_sm)"
+echo "  - spaCy Chinese model (zh_core_web_sm)"
+echo "=================================================="
+echo
+
+# Function to check if a command exists
+command_exists() {
+    command -v "$1" >/dev/null 2>&1
+}
+
+# Function to activate virtual environment if it exists
+activate_venv() {
+    if [[ -n "$VIRTUAL_ENV" ]]; then
+        echo "✅ Virtual environment already active: $VIRTUAL_ENV"
+        return 0
+    fi
+    
+    # Check for common virtual environment locations
+    local venv_paths=(
+        "$PROJECT_ROOT/venv"
+        "$PROJECT_ROOT/.venv" 
+        "$PROJECT_ROOT/env"
+        "$PROJECT_ROOT/.env"
+    )
+    
+    for venv_path in "${venv_paths[@]}"; do
+        if [[ -f "$venv_path/bin/activate" ]]; then
+            echo "📦 Activating virtual environment: $venv_path"
+            source "$venv_path/bin/activate"
+            return 0
+        fi
+    done
+    
+    echo "⚠️  No virtual environment found. Using system Python."
+    return 1
+}
+
+# Function to check Python and packages
+check_dependencies() {
+    echo "🔍 Checking dependencies..."
+    
+    if ! command_exists python3; then
+        echo "❌ Python 3 is not installed or not in PATH"
+        exit 1
+    fi
+    
+    local python_version=$(python3 --version 2>&1 | cut -d' ' -f2)
+    echo "✅ Python version: $python_version"
+    
+    # Check if we're in the project directory and can import aiecs
+    cd "$PROJECT_ROOT"
+    if python3 -c "import aiecs" 2>/dev/null; then
+        echo "✅ AIECS package is available"
+    else
+        echo "⚠️  AIECS package not found. You may need to install it first:"
+        echo "    pip install -e ."
+    fi
+}
+
+# Function to run the Python download script
+run_download_script() {
+    echo
+    echo "🚀 Starting NLP data download..."
+    echo
+    
+    cd "$PROJECT_ROOT"
+    
+    # Try multiple ways to run the script
+    if python3 -m aiecs.scripts.download_nlp_data; then
+        echo "✅ NLP data download completed successfully!"
+        return 0
+    elif python3 aiecs/scripts/download_nlp_data.py; then
+        echo "✅ NLP data download completed successfully!"
+        return 0
+    else
+        echo "❌ Failed to run NLP data download script"
+        return 1
+    fi
+}
+
+# Function to verify installation
+verify_installation() {
+    echo
+    echo "🔍 Verifying NLP data installation..."
+    
+    # Test NLTK
+    if python3 -c "
+import nltk
+from nltk.corpus import stopwords
+stopwords.words('english')
+print('✅ NLTK stopwords data available')
+" 2>/dev/null; then
+        echo "✅ NLTK verification passed"
+    else
+        echo "⚠️  NLTK verification failed"
+    fi
+    
+    # Test spaCy English model
+    if python3 -c "
+import spacy
+nlp = spacy.load('en_core_web_sm')
+doc = nlp('This is a test.')
+print('✅ spaCy English model available')
+" 2>/dev/null; then
+        echo "✅ spaCy English model verification passed"
+    else
+        echo "⚠️  spaCy English model verification failed"
+    fi
+    
+    # Test spaCy Chinese model (optional)
+    if python3 -c "
+import spacy
+nlp = spacy.load('zh_core_web_sm')
+doc = nlp('这是测试。')
+print('✅ spaCy Chinese model available')
+" 2>/dev/null; then
+        echo "✅ spaCy Chinese model verification passed"
+    else
+        echo "⚠️  spaCy Chinese model not available (optional)"
+    fi
+}
+
+# Function to display usage information
+show_usage() {
+    echo "Usage: $0 [OPTIONS]"
+    echo
+    echo "Options:"
+    echo "  -h, --help     Show this help message"
+    echo "  -v, --verify   Only verify existing installations"
+    echo "  --no-venv      Skip virtual environment activation"
+    echo
+    echo "This script downloads required NLP data for AIECS ClassifierTool:"
+    echo "  - NLTK stopwords corpus"
+    echo "  - spaCy English model (en_core_web_sm)"
+    echo "  - spaCy Chinese model (zh_core_web_sm, optional)"
+    echo
+}
+
+# Parse command line arguments
+VERIFY_ONLY=false
+SKIP_VENV=false
+
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        -h|--help)
+            show_usage
+            exit 0
+            ;;
+        -v|--verify)
+            VERIFY_ONLY=true
+            shift
+            ;;
+        --no-venv)
+            SKIP_VENV=true
+            shift
+            ;;
+        *)
+            echo "Unknown option: $1"
+            show_usage
+            exit 1
+            ;;
+    esac
+done
+
+# Main execution
+main() {
+    echo "📍 Project root: $PROJECT_ROOT"
+    echo
+    
+    # Activate virtual environment if available and not skipped
+    if [[ "$SKIP_VENV" != true ]]; then
+        activate_venv || true
+    fi
+    
+    # Check dependencies
+    check_dependencies
+    
+    if [[ "$VERIFY_ONLY" == true ]]; then
+        echo
+        echo "🔍 Running verification only..."
+        verify_installation
+    else
+        # Download NLP data
+        if run_download_script; then
+            verify_installation
+            echo
+            echo "🎉 NLP data setup completed successfully!"
+            echo "AIECS ClassifierTool is ready to use."
+        else
+            echo
+            echo "❌ NLP data setup failed. Please check the errors above."
+            exit 1
+        fi
+    fi
+    
+    echo
+    echo "=================================================="
+    echo "Setup complete!"
+    echo "=================================================="
+}
+
+# Run main function
+main "$@"

aiecs/tasks/__init__.py

@@ -0,0 +1,2 @@
+# This file makes the app/tasks directory a Python package
+from .worker import celery_app

aiecs/tasks/worker.py

@@ -0,0 +1,111 @@
+from celery import Celery
+from aiecs.config.config import get_settings
+from aiecs.domain.task.task_context import build_context
+from aiecs.config.registry import get_ai_service
+from aiecs.ws.socket_server import push_progress
+import logging
+import json
+from enum import Enum
+from typing import Dict, Any, Optional
+
+logger = logging.getLogger(__name__)
+
+settings = get_settings()
+celery_app = Celery("ai_worker", broker=settings.celery_broker_url)
+
+# Configure Celery
+celery_app.conf.update(
+    task_serializer='json',
+    accept_content=['json'],
+    result_serializer='json',
+    timezone='UTC',
+    enable_utc=True,
+    task_queues={
+        'fast_tasks': {'exchange': 'fast_tasks', 'routing_key': 'fast_tasks'},
+        'heavy_tasks': {'exchange': 'heavy_tasks', 'routing_key': 'heavy_tasks'}
+    },
+    task_routes={
+        'aiecs.tasks.worker.execute_task': {'queue': 'fast_tasks'},
+        'aiecs.tasks.worker.execute_heavy_task': {'queue': 'heavy_tasks'}
+    }
+)
+
+from aiecs.domain.execution.model import TaskStatus
+
+@celery_app.task(bind=True, name="aiecs.tasks.worker.execute_task")
+def execute_task(self, task_name: str, user_id: str, task_id: str, step: int,
+                 mode: str, service: str, input_data: Dict[str, Any], context: Dict[str, Any]):
+    """
+    Execute a fast task from the service executor queue.
+    This task is used for operations that should complete quickly.
+    """
+    logger.info(f"Executing fast task: {task_name} for user {user_id}, task {task_id}, step {step}")
+    return _execute_service_task(self, task_name, user_id, task_id, step, mode, service, input_data, context)
+
+@celery_app.task(bind=True, name="aiecs.tasks.worker.execute_heavy_task")
+def execute_heavy_task(self, task_name: str, user_id: str, task_id: str, step: int,
+                       mode: str, service: str, input_data: Dict[str, Any], context: Dict[str, Any]):
+    """
+    Execute a heavy task from the service executor queue.
+    This task is used for operations that may take longer to complete.
+    """
+    logger.info(f"Executing heavy task: {task_name} for user {user_id}, task {task_id}, step {step}")
+    return _execute_service_task(self, task_name, user_id, task_id, step, mode, service, input_data, context)
+
+def _execute_service_task(self, task_name: str, user_id: str, task_id: str, step: int,
+                         mode: str, service: str, input_data: Dict[str, Any], context: Dict[str, Any]):
+    """
+    Common implementation for executing both fast and heavy tasks.
+    This function handles the actual task execution logic.
+    """
+    try:
+        # 1. Push started status
+        push_progress(user_id, {
+            "status": TaskStatus.RUNNING.value,
+            "step": step,
+            "task": task_name,
+            "message": f"Executing task: {task_name}"
+        })
+
+        # 2. Get the service instance
+        service_cls = get_ai_service(mode, service)
+        service_instance = service_cls()
+
+        # 3. Execute the task
+        if hasattr(service_instance, task_name) and callable(getattr(service_instance, task_name)):
+            method = getattr(service_instance, task_name)
+            result = method(input_data, context)
+        else:
+            # Fallback to a generic execution method if the specific task method doesn't exist
+            result = service_instance.execute_task(task_name, input_data, context)
+
+        # 4. Push completed status
+        push_progress(user_id, {
+            "status": TaskStatus.COMPLETED.value,
+            "step": step,
+            "task": task_name,
+            "result": result,
+            "message": f"Completed task: {task_name}"
+        })
+
+        return {
+            "status": TaskStatus.COMPLETED.value,
+            "task": task_name,
+            "result": result
+        }
+    except Exception as e:
+        logger.error(f"Error executing task {task_name}: {str(e)}", exc_info=True)
+        # Push error status
+        push_progress(user_id, {
+            "status": TaskStatus.FAILED.value,
+            "step": step,
+            "task": task_name,
+            "error": str(e),
+            "message": f"Failed to execute task: {task_name}"
+        })
+
+        return {
+            "status": TaskStatus.FAILED.value,
+            "task": task_name,
+            "error": str(e)
+        }

aiecs/tools/__init__.py

@@ -0,0 +1,196 @@
+# python-middleware/app/tools/__init__.py
+
+import importlib
+import inspect
+import logging
+import os
+import pkgutil
+from typing import Any, Dict, List, Optional, Type
+
+from aiecs.tools.base_tool import BaseTool
+
+logger = logging.getLogger(__name__)
+
+# 全局工具注册表
+TOOL_REGISTRY = {}
+TOOL_CLASSES = {}
+TOOL_CONFIGS = {}
+
+def register_tool(name):
+    """
+    装饰器，用于注册工具类
+
+    Args:
+        name: 工具名称
+
+    Returns:
+        装饰后的类
+    """
+    def wrapper(cls):
+        # 存储工具类，但不立即实例化
+        TOOL_CLASSES[name] = cls
+        # 兼容旧版本：如果类继承自BaseTool，则不立即实例化
+        if not issubclass(cls, BaseTool):
+            TOOL_REGISTRY[name] = cls()
+        return cls
+    return wrapper
+
+def get_tool(name):
+    """
+    获取工具实例
+
+    Args:
+        name: 工具名称
+
+    Returns:
+        工具实例
+
+    Raises:
+        ValueError: 如果工具未注册
+    """
+    if name not in TOOL_REGISTRY and name in TOOL_CLASSES:
+        # 延迟实例化BaseTool子类
+        tool_class = TOOL_CLASSES[name]
+        config = TOOL_CONFIGS.get(name, {})
+        TOOL_REGISTRY[name] = tool_class(config)
+
+    if name not in TOOL_REGISTRY:
+        raise ValueError(f"Tool '{name}' is not registered")
+
+    return TOOL_REGISTRY[name]
+
+def list_tools():
+    """
+    列出所有已注册的工具
+
+    Returns:
+        工具信息字典列表
+    """
+    tools = []
+    all_tool_names = list(set(list(TOOL_REGISTRY.keys()) + list(TOOL_CLASSES.keys())))
+    
+    for tool_name in all_tool_names:
+        try:
+            # 优先使用已有实例的信息
+            if tool_name in TOOL_REGISTRY:
+                tool_instance = TOOL_REGISTRY[tool_name]
+                tool_info = {
+                    "name": tool_name,
+                    "description": getattr(tool_instance, 'description', f'{tool_name} tool'),
+                    "category": getattr(tool_instance, 'category', 'general'),
+                    "class_name": tool_instance.__class__.__name__,
+                    "module": tool_instance.__class__.__module__,
+                    "status": "loaded"
+                }
+            elif tool_name in TOOL_CLASSES:
+                # 从类定义获取信息，但不实例化
+                tool_class = TOOL_CLASSES[tool_name]
+                tool_info = {
+                    "name": tool_name,
+                    "description": getattr(tool_class, 'description', f'{tool_name} tool'),
+                    "category": getattr(tool_class, 'category', 'general'),
+                    "class_name": tool_class.__name__,
+                    "module": tool_class.__module__,
+                    "status": "available"
+                }
+            else:
+                continue
+            
+            tools.append(tool_info)
+            
+        except Exception as e:
+            logger.warning(f"Failed to get info for tool {tool_name}: {e}")
+            # 提供基本信息
+            tools.append({
+                "name": tool_name,
+                "description": f"{tool_name} (info unavailable)",
+                "category": "unknown",
+                "class_name": "Unknown",
+                "module": "unknown",
+                "status": "error"
+            })
+    
+    return tools
+
+def discover_tools(package_path: str = "aiecs.tools"):
+    """
+    发现并注册包中的所有工具
+
+    Args:
+        package_path: 要搜索的包路径
+    """
+    package = importlib.import_module(package_path)
+    package_dir = os.path.dirname(package.__file__)
+
+    for _, module_name, is_pkg in pkgutil.iter_modules([package_dir]):
+        if is_pkg:
+            # 递归搜索子包中的工具
+            discover_tools(f"{package_path}.{module_name}")
+        else:
+            # 导入模块
+            try:
+                importlib.import_module(f"{package_path}.{module_name}")
+            except Exception as e:
+                logger.error(f"Error importing module {module_name}: {e}")
+
+# 导入基础工具类供继承使用
+from aiecs.tools.base_tool import BaseTool
+
+# Lazy loading strategy: don't import all tools at package init
+# Tools will be loaded on-demand when requested
+
+def _ensure_task_tools_available():
+    """Ensure task_tools module is available for lazy loading"""
+    try:
+        from . import task_tools
+        return True
+    except ImportError as e:
+        logger.error(f"Failed to import task_tools: {e}")
+        return False
+
+def _register_known_tools():
+    """Register known tools without importing heavy dependencies"""
+    # Pre-register tool classes for discovery without importing modules
+    # This allows list_tools() to work before actual tool loading
+    
+    known_tools = [
+        ("chart_tool", "Chart and visualization operations"),
+        ("classfire_tool", "Text classification and keyword extraction"),
+        ("image_tool", "Image processing and OCR operations"),
+        ("office_tool", "Office document processing"),
+        ("pandas_tool", "Data analysis and manipulation"), 
+        ("report_tool", "Report generation and formatting"),
+        ("research_tool", "Research and information gathering"),
+        ("scraper_tool", "Web scraping and data extraction"),
+        ("search_api", "Search API integration"),
+        ("stats_tool", "Statistical analysis and computation")
+    ]
+    
+    # Register as placeholder until actually loaded
+    for tool_name, description in known_tools:
+        if tool_name not in TOOL_REGISTRY and tool_name not in TOOL_CLASSES:
+            # Create a placeholder class for discovery
+            class ToolPlaceholder:
+                def __init__(self, name, desc):
+                    self.name = name
+                    self.description = desc
+                    self.category = "task"
+                    self.is_placeholder = True
+            
+            TOOL_REGISTRY[tool_name] = ToolPlaceholder(tool_name, description)
+
+# Register known tools for discovery
+_register_known_tools()
+
+try:
+    from . import db_api
+except ImportError:
+    pass
+
+try:
+    from . import vector_search
+except ImportError:
+    pass
+
+# Don't auto-discover tools at import time for performance
+# Tools will be discovered when explicitly requested via discover_tools() call