aiecs 1.0.1__py3-none-any.whl → 1.7.17__py3-none-any.whl

aiecs/tools/task_tools/classfire_tool.py

@@ -1,53 +1,63 @@
+from aiecs.tools import register_tool
+from aiecs.tools.tool_executor import (
+    validate_input,
+)
+from aiecs.tools.base_tool import BaseTool
 import os
 import re
 import logging
 import asyncio
 import time
-from typing import Dict, Any, List, Optional, Union, Tuple
+from typing import Dict, Any, List, Optional, Tuple
 from enum import Enum
 
-from pydantic import BaseModel, Field, field_validator, ValidationError, ConfigDict
+from pydantic import BaseModel, Field, field_validator
+from pydantic_settings import BaseSettings, SettingsConfigDict
 
 # Lazy imports for heavy dependencies
 rake_nltk = None
 spacy = None
 
+
 def _init_heavy_dependencies():
     """Initialize heavy dependencies when actually needed"""
     global rake_nltk, spacy
-    
+
     if rake_nltk is None:
         try:
-            import rake_nltk as _rake_nltk
+            import rake_nltk as _rake_nltk  # type: ignore[import-untyped]
+
             rake_nltk = _rake_nltk
         except ImportError:
             import logging
+
             logging.getLogger(__name__).error("rake_nltk not available")
-            
+
     if spacy is None:
         try:
             import spacy as _spacy
+
             spacy = _spacy
         except ImportError:
             import logging
+
             logging.getLogger(__name__).warning("spacy not available (optional)")
 
-from aiecs.tools import register_tool
-from aiecs.tools.base_tool import BaseTool
-from aiecs.tools.tool_executor import (
-    validate_input,
-)
 
 # Enums for configuration options
+
+
 class Language(str, Enum):
     ENGLISH = "en"
     CHINESE = "zh"
     AUTO = "auto"
 
+
 class ModelType(str, Enum):
     SPACY_ENGLISH = "en_core_web_sm"
     SPACY_CHINESE = "zh_core_web_sm"
 
+
 @register_tool("classifier")
 class ClassifierTool(BaseTool):
     """
@@ -69,182 +79,126 @@ class ClassifierTool(BaseTool):
     """
 
     # Configuration schema
-    class Config(BaseModel):
-        """Configuration for the classifier tool"""
+    class Config(BaseSettings):
+        """Configuration for the classifier tool
+        
+        Automatically reads from environment variables with CLASSIFIER_TOOL_ prefix.
+        Example: CLASSIFIER_TOOL_MAX_WORKERS -> max_workers
+        """
+
+        model_config = SettingsConfigDict(env_prefix="CLASSIFIER_TOOL_")
+
         max_workers: int = Field(
             default=min(32, (os.cpu_count() or 4) * 2),
-            description="Maximum number of worker threads"
+            description="Maximum number of worker threads",
         )
         pipeline_cache_ttl: int = Field(
             default=3600,
-            description="Time-to-live for pipeline cache in seconds"
-        )
-        pipeline_cache_size: int = Field(
-            default=10,
-            description="Maximum number of pipeline cache entries"
-        )
-        max_text_length: int = Field(
-            default=10_000,
-            description="Maximum text length in characters"
-        )
-        spacy_model_en: str = Field(
-            default="en_core_web_sm",
-            description="spaCy model for English"
-        )
-        spacy_model_zh: str = Field(
-            default="zh_core_web_sm",
-            description="spaCy model for Chinese"
+            description="Time-to-live for pipeline cache in seconds",
         )
+        pipeline_cache_size: int = Field(default=10, description="Maximum number of pipeline cache entries")
+        max_text_length: int = Field(default=10_000, description="Maximum text length in characters")
+        spacy_model_en: str = Field(default="en_core_web_sm", description="spaCy model for English")
+        spacy_model_zh: str = Field(default="zh_core_web_sm", description="spaCy model for Chinese")
         allowed_models: List[str] = Field(
-            default=[
-                "en_core_web_sm",
-                "zh_core_web_sm"
-            ],
-            description="List of allowed spaCy models"
-        )
-        rate_limit_enabled: bool = Field(
-            default=True,
-            description="Enable rate limiting"
+            default=["en_core_web_sm", "zh_core_web_sm"],
+            description="List of allowed spaCy models",
         )
-        rate_limit_requests: int = Field(
-            default=100,
-            description="Maximum requests per window"
-        )
-        rate_limit_window: int = Field(
-            default=60,
-            description="Rate limit window in seconds"
-        )
-        use_rake_for_english: bool = Field(
-            default=True,
-            description="Use RAKE for English phrase extraction"
-        )
-
-        model_config = ConfigDict(env_prefix="CLASSIFIER_TOOL_")
+        rate_limit_enabled: bool = Field(default=True, description="Enable rate limiting")
+        rate_limit_requests: int = Field(default=100, description="Maximum requests per window")
+        rate_limit_window: int = Field(default=60, description="Rate limit window in seconds")
+        use_rake_for_english: bool = Field(default=True, description="Use RAKE for English phrase extraction")
 
     # Base schema for text operations
     class BaseTextSchema(BaseModel):
         """Base schema for text operations"""
-        text: str = Field(
-            description="Text to process"
-        )
+
+        text: str = Field(description="Text to process")
 
         @field_validator("text")
         @classmethod
         def check_length_and_content(cls, v: str) -> str:
             if len(v) > 10_000:  # Using a constant here for validation
-                raise ValueError(f"Text length exceeds 10,000 characters")
+                raise ValueError("Text length exceeds 10,000 characters")
             # Check for malicious patterns (e.g., SQL injection)
-            if re.search(r'(\bSELECT\b|\bINSERT\b|\bDELETE\b|--|;|/\*)', v, re.IGNORECASE):
+            if re.search(
+                r"(\bSELECT\b|\bINSERT\b|\bDELETE\b|--|;|/\*)",
+                v,
+                re.IGNORECASE,
+            ):
                 raise ValueError("Text contains potentially malicious content")
             return v
 
     # Input schemas for operations
     class ClassifySchema(BaseTextSchema):
-        """Schema for text classification"""
-        model: Optional[str] = Field(
-            default=None,
-            description="Model to use for classification"
-        )
-        language: Optional[Language] = Field(
-            default=None,
-            description="Language of the text"
-        )
+        """Schema for classify operation"""
+
+        model: Optional[str] = Field(default=None, description="Model to use for classification")
+        language: Optional[Language] = Field(default=None, description="Language of the text")
 
         @field_validator("model")
         @classmethod
         def check_model(cls, v: Optional[str]) -> Optional[str]:
-            allowed_models = [
-                "en_core_web_sm",
-                "zh_core_web_sm"
-            ]
+            allowed_models = ["en_core_web_sm", "zh_core_web_sm"]
             if v and v not in allowed_models:
                 raise ValueError(f"Model '{v}' not in allowed spaCy models: {allowed_models}")
             return v
 
     class TokenizeSchema(BaseTextSchema):
-        """Schema for text tokenization"""
-        language: Optional[Language] = Field(
-            default=None,
-            description="Language of the text"
-        )
+        """Schema for tokenize operation"""
 
-    class PosTagSchema(BaseTextSchema):
-        """Schema for part-of-speech tagging"""
-        language: Optional[Language] = Field(
-            default=None,
-            description="Language of the text"
-        )
+        language: Optional[Language] = Field(default=None, description="Language of the text")
+
+    class Pos_tagSchema(BaseTextSchema):
+        """Schema for pos_tag operation"""
+
+        language: Optional[Language] = Field(default=None, description="Language of the text")
 
     class NERSchema(BaseTextSchema):
-        """Schema for named entity recognition"""
-        language: Optional[Language] = Field(
-            default=None,
-            description="Language of the text"
-        )
+        """Schema for ner operation"""
+
+        language: Optional[Language] = Field(default=None, description="Language of the text")
 
     class LemmatizeSchema(BaseTextSchema):
-        """Schema for lemmatization"""
-        language: Optional[Language] = Field(
-            default=None,
-            description="Language of the text"
-        )
+        """Schema for lemmatize operation"""
 
-    class DependencyParseSchema(BaseTextSchema):
-        """Schema for dependency parsing"""
-        language: Optional[Language] = Field(
-            default=None,
-            description="Language of the text"
-        )
+        language: Optional[Language] = Field(default=None, description="Language of the text")
 
-    class KeywordExtractSchema(BaseTextSchema):
-        """Schema for keyword extraction"""
-        top_k: int = Field(
-            default=10,
-            description="Number of keywords to extract"
-        )
-        language: Optional[Language] = Field(
-            default=None,
-            description="Language of the text"
-        )
+    class Dependency_parseSchema(BaseTextSchema):
+        """Schema for dependency_parse operation"""
+
+        language: Optional[Language] = Field(default=None, description="Language of the text")
+
+    class Keyword_extractSchema(BaseTextSchema):
+        """Schema for keyword_extract operation"""
+
+        top_k: int = Field(default=10, description="Number of keywords to extract")
+        language: Optional[Language] = Field(default=None, description="Language of the text")
         extract_phrases: bool = Field(
             default=True,
-            description="Whether to extract phrases or just keywords"
+            description="Whether to extract phrases or just keywords",
         )
 
     class SummarizeSchema(BaseTextSchema):
-        """Schema for text summarization"""
-        max_length: int = Field(
-            default=150,
-            description="Maximum length of the summary"
-        )
-        language: Optional[Language] = Field(
-            default=None,
-            description="Language of the text"
-        )
+        """Schema for summarize operation"""
+
+        max_length: int = Field(default=150, description="Maximum length of the summary")
+        language: Optional[Language] = Field(default=None, description="Language of the text")
 
-    class BatchProcessSchema(BaseModel):
+    class Batch_processSchema(BaseModel):
         """Schema for batch processing"""
-        texts: List[str] = Field(
-            description="List of texts to process"
-        )
-        operation: str = Field(
-            description="Operation to perform on each text"
-        )
-        language: Optional[Language] = Field(
-            default=None,
-            description="Language of the texts"
-        )
-        model: Optional[str] = Field(
-            default=None,
-            description="Model to use for processing"
-        )
+
+        texts: List[str] = Field(description="List of texts to process")
+        operation: str = Field(description="Operation to perform on each text")
+        language: Optional[Language] = Field(default=None, description="Language of the texts")
+        model: Optional[str] = Field(default=None, description="Model to use for processing")
         top_k: Optional[int] = Field(
             default=None,
-            description="Number of keywords to extract (for keyword_extract)"
+            description="Number of keywords to extract (for keyword_extract)",
         )
         max_length: Optional[int] = Field(
             default=None,
-            description="Maximum length of the summary (for summarize)"
+            description="Maximum length of the summary (for summarize)",
         )
 
         @field_validator("texts")
@@ -252,8 +206,12 @@ class ClassifierTool(BaseTool):
         def check_texts(cls, v: List[str]) -> List[str]:
             for text in v:
                 if len(text) > 10_000:  # Using a constant here for validation
-                    raise ValueError(f"Text length exceeds 10,000 characters")
-                if re.search(r'(\bSELECT\b|\bINSERT\b|\bDELETE\b|--|;|/\*)', text, re.IGNORECASE):
+                    raise ValueError("Text length exceeds 10,000 characters")
+                if re.search(
+                    r"(\bSELECT\b|\bINSERT\b|\bDELETE\b|--|;|/\*)",
+                    text,
+                    re.IGNORECASE,
+                ):
                     raise ValueError("Text contains potentially malicious content")
             return v
 
@@ -266,24 +224,31 @@ class ClassifierTool(BaseTool):
 
         Raises:
             ValueError: If config contains invalid settings.
+        
+        Configuration is automatically loaded by BaseTool from:
+        1. Explicit config dict (highest priority)
+        2. YAML config files (config/tools/classifier.yaml)
+        3. Environment variables (via dotenv from .env files)
+        4. Tool defaults (lowest priority)
         """
         super().__init__(config)
 
-        # Parse configuration
-        self.config = self.Config(**(config or {}))
+        # Configuration is automatically loaded by BaseTool into self._config_obj
+        # Access config via self._config_obj (BaseSettings instance)
+        self.config = self._config_obj if self._config_obj else self.Config()
 
         # Set up logger
         self.logger = logging.getLogger(__name__)
         if not self.logger.handlers:
             handler = logging.StreamHandler()
-            handler.setFormatter(logging.Formatter('%(asctime)s %(levelname)s %(message)s'))
+            handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s"))
             self.logger.addHandler(handler)
         self.logger.setLevel(logging.INFO)
 
         # Initialize resources
-        self._spacy_nlp = {}  # Language -> spaCy pipeline
-        self._metrics = {'requests': 0, 'cache_hits': 0, 'processing_time': []}
-        self._request_timestamps = []
+        self._spacy_nlp: Dict[str, Any] = {}  # Language -> spaCy pipeline
+        self._metrics = {"requests": 0, "cache_hits": 0, "processing_time": []}
+        self._request_timestamps: List[float] = []
 
     def _get_sentiment_lexicon(self, language: str) -> Dict[str, float]:
         """
@@ -295,22 +260,66 @@ class ClassifierTool(BaseTool):
         Returns:
             Dict[str, float]: Sentiment lexicon with word -> score mapping.
         """
-        if language == 'en':
+        if language == "en":
             # Simple English sentiment lexicon
             return {
-                'good': 1.0, 'great': 1.5, 'excellent': 2.0, 'amazing': 2.0, 'wonderful': 1.5,
-                'fantastic': 2.0, 'awesome': 1.5, 'perfect': 2.0, 'love': 1.5, 'like': 1.0,
-                'happy': 1.5, 'pleased': 1.0, 'satisfied': 1.0, 'positive': 1.0, 'best': 2.0,
-                'bad': -1.0, 'terrible': -2.0, 'awful': -2.0, 'horrible': -2.0, 'hate': -2.0,
-                'dislike': -1.0, 'sad': -1.5, 'angry': -1.5, 'disappointed': -1.5, 'negative': -1.0,
-                'worst': -2.0, 'poor': -1.0, 'fail': -1.5, 'wrong': -1.0, 'problem': -1.0
+                "good": 1.0,
+                "great": 1.5,
+                "excellent": 2.0,
+                "amazing": 2.0,
+                "wonderful": 1.5,
+                "fantastic": 2.0,
+                "awesome": 1.5,
+                "perfect": 2.0,
+                "love": 1.5,
+                "like": 1.0,
+                "happy": 1.5,
+                "pleased": 1.0,
+                "satisfied": 1.0,
+                "positive": 1.0,
+                "best": 2.0,
+                "bad": -1.0,
+                "terrible": -2.0,
+                "awful": -2.0,
+                "horrible": -2.0,
+                "hate": -2.0,
+                "dislike": -1.0,
+                "sad": -1.5,
+                "angry": -1.5,
+                "disappointed": -1.5,
+                "negative": -1.0,
+                "worst": -2.0,
+                "poor": -1.0,
+                "fail": -1.5,
+                "wrong": -1.0,
+                "problem": -1.0,
             }
         else:  # Chinese
             return {
-                '好': 1.0, '很好': 1.5, '非常好': 2.0, '棒': 1.5, '优秀': 2.0, '完美': 2.0,
-                '喜欢': 1.5, '爱': 2.0, '满意': 1.0, '开心': 1.5, '高兴': 1.5, '积极': 1.0,
-                '坏': -1.0, '很坏': -1.5, '糟糕': -2.0, '讨厌': -2.0, '恨': -2.0, '失望': -1.5,
-                '生气': -1.5, '愤怒': -2.0, '消极': -1.0, '问题': -1.0, '错误': -1.0, '失败': -1.5
+                "好": 1.0,
+                "很好": 1.5,
+                "非常好": 2.0,
+                "棒": 1.5,
+                "优秀": 2.0,
+                "完美": 2.0,
+                "喜欢": 1.5,
+                "爱": 2.0,
+                "满意": 1.0,
+                "开心": 1.5,
+                "高兴": 1.5,
+                "积极": 1.0,
+                "坏": -1.0,
+                "很坏": -1.5,
+                "糟糕": -2.0,
+                "讨厌": -2.0,
+                "恨": -2.0,
+                "失望": -1.5,
+                "生气": -1.5,
+                "愤怒": -2.0,
+                "消极": -1.0,
+                "问题": -1.0,
+                "错误": -1.0,
+                "失败": -1.5,
             }
 
     def _get_spacy(self, language: str) -> Any:
@@ -327,11 +336,12 @@ class ClassifierTool(BaseTool):
         if spacy is None:
             try:
                 import spacy as spacy_module
+
                 spacy = spacy_module
             except ImportError:
                 raise ImportError("spaCy is required but not installed. Please install it with: pip install spacy")
 
-        model = self.config.spacy_model_zh if language == 'zh' else self.config.spacy_model_en
+        model = self.config.spacy_model_zh if language == "zh" else self.config.spacy_model_en
         return spacy.load(model, disable=["textcat"])
 
     def _detect_language(self, text: str) -> str:
@@ -346,17 +356,17 @@ class ClassifierTool(BaseTool):
         """
         try:
             # Count Chinese characters (CJK Unified Ideographs)
-            chinese_chars = sum(1 for char in text if '\u4e00' <= char <= '\u9fff')
+            chinese_chars = sum(1 for char in text if "\u4e00" <= char <= "\u9fff")
             total_chars = len([char for char in text if char.isalpha()])
 
             if total_chars == 0:
-                return 'en'
+                return "en"
 
             # If more than 30% are Chinese characters, consider it Chinese
             chinese_ratio = chinese_chars / total_chars
-            return 'zh' if chinese_ratio > 0.3 else 'en'
+            return "zh" if chinese_ratio > 0.3 else "en"
         except Exception:
-            return 'en'
+            return "en"
 
     def _check_rate_limit(self) -> bool:
         """
@@ -373,8 +383,7 @@ class ClassifierTool(BaseTool):
         # Get lock from executor
         with self._executor.get_lock("rate_limit"):
             # Remove timestamps outside the window
-            self._request_timestamps = [ts for ts in self._request_timestamps
-                                      if current_time - ts <= self.config.rate_limit_window]
+            self._request_timestamps = [ts for ts in self._request_timestamps if current_time - ts <= self.config.rate_limit_window]
 
             # Check if we're at the limit
             if len(self._request_timestamps) >= self.config.rate_limit_requests:
@@ -398,10 +407,10 @@ class ClassifierTool(BaseTool):
         try:
             # Initialize heavy dependencies if needed
             _init_heavy_dependencies()
-            
+
             if rake_nltk is None:
                 raise ImportError("rake_nltk not available")
-                
+
             rake = rake_nltk.Rake()
             rake.extract_keywords_from_text(text)
             phrases = rake.get_ranked_phrases()[:top_k]
@@ -409,9 +418,9 @@ class ClassifierTool(BaseTool):
         except Exception as e:
             self.logger.error(f"Error extracting English phrases: {e}")
             # Fallback to simple keyword extraction
-            nlp = self._get_spacy('en')
+            nlp = self._get_spacy("en")
             doc = nlp(text)
-            keywords = [token.text for token in doc if token.pos_ in ('NOUN', 'PROPN')][:top_k]
+            keywords = [token.text for token in doc if token.pos_ in ("NOUN", "PROPN")][:top_k]
             return keywords
 
     def _extract_chinese_phrases(self, text: str, top_k: int) -> List[str]:
@@ -426,7 +435,7 @@ class ClassifierTool(BaseTool):
             List[str]: Extracted phrases.
         """
         try:
-            nlp = self._get_spacy('zh')
+            nlp = self._get_spacy("zh")
             doc = nlp(text)
 
             # Extract noun phrases and named entities
@@ -444,7 +453,7 @@ class ClassifierTool(BaseTool):
 
             # Add important nouns and proper nouns
             for token in doc:
-                if token.pos_ in ('NOUN', 'PROPN') and len(token.text.strip()) > 1:
+                if token.pos_ in ("NOUN", "PROPN") and len(token.text.strip()) > 1:
                     phrases.append(token.text.strip())
 
             # Remove duplicates and return top_k
@@ -455,9 +464,9 @@ class ClassifierTool(BaseTool):
             self.logger.error(f"Error extracting Chinese phrases with spaCy: {e}")
             # Fallback to simple noun extraction
             try:
-                nlp = self._get_spacy('zh')
+                nlp = self._get_spacy("zh")
                 doc = nlp(text)
-                nouns = [token.text for token in doc if token.pos_ in ('NOUN', 'PROPN')]
+                nouns = [token.text for token in doc if token.pos_ in ("NOUN", "PROPN")]
                 return nouns[:top_k]
             except Exception:
                 return []
@@ -478,14 +487,20 @@ class ClassifierTool(BaseTool):
             ValueError: If the pipeline creation fails.
         """
         try:
-            from transformers import pipeline
+            from transformers import pipeline  # type: ignore[import-not-found]
+
             return pipeline(task, model=model)
         except ImportError:
             raise ImportError("transformers library is required for summarization but not installed. Please install it with: pip install transformers")
         except Exception as e:
             raise ValueError(f"Error creating pipeline for task '{task}' with model '{model}': {e}")
 
-    async def classify(self, text: str, model: Optional[str] = None, language: Optional[str] = None) -> List[Dict[str, Any]]:
+    async def classify(
+        self,
+        text: str,
+        model: Optional[str] = None,
+        language: Optional[str] = None,
+    ) -> List[Dict[str, Any]]:
         """
         Perform sentiment classification on text using spaCy and lexicon-based approach.
 
@@ -503,16 +518,12 @@ class ClassifierTool(BaseTool):
         language = language or self._detect_language(text)
 
         # Get spaCy pipeline and sentiment lexicon
-        nlp = await asyncio.get_event_loop().run_in_executor(
-            None, self._get_spacy, language
-        )
+        nlp = await asyncio.get_event_loop().run_in_executor(None, self._get_spacy, language)
 
         sentiment_lexicon = self._get_sentiment_lexicon(language)
 
         # Process text with spaCy
-        doc = await asyncio.get_event_loop().run_in_executor(
-            None, nlp, text
-        )
+        doc = await asyncio.get_event_loop().run_in_executor(None, nlp, text)
 
         # Calculate sentiment score
         sentiment_score = 0.0
@@ -556,13 +567,9 @@ class ClassifierTool(BaseTool):
 
         language = language or self._detect_language(text)
 
-        nlp = await asyncio.get_event_loop().run_in_executor(
-            None, self._get_spacy, language
-        )
+        nlp = await asyncio.get_event_loop().run_in_executor(None, self._get_spacy, language)
 
-        doc = await asyncio.get_event_loop().run_in_executor(
-            None, nlp, text
-        )
+        doc = await asyncio.get_event_loop().run_in_executor(None, nlp, text)
 
         return [token.text for token in doc]
 
@@ -582,18 +589,12 @@ class ClassifierTool(BaseTool):
 
         language = language or self._detect_language(text)
 
-        nlp = await asyncio.get_event_loop().run_in_executor(
-            None, self._get_spacy, language
-        )
+        nlp = await asyncio.get_event_loop().run_in_executor(None, self._get_spacy, language)
 
-        doc = await asyncio.get_event_loop().run_in_executor(
-            None, nlp, text
-        )
+        doc = await asyncio.get_event_loop().run_in_executor(None, nlp, text)
 
         return [(token.text, token.pos_) for token in doc]
 
-    @validate_input(NERSchema)
-
     async def ner(self, text: str, language: Optional[str] = None) -> List[Dict[str, Any]]:
         """
         Perform named entity recognition.
@@ -610,21 +611,20 @@ class ClassifierTool(BaseTool):
 
         language = language or self._detect_language(text)
 
-        nlp = await asyncio.get_event_loop().run_in_executor(
-            None, self._get_spacy, language
-        )
+        nlp = await asyncio.get_event_loop().run_in_executor(None, self._get_spacy, language)
 
-        doc = await asyncio.get_event_loop().run_in_executor(
-            None, nlp, text
-        )
+        doc = await asyncio.get_event_loop().run_in_executor(None, nlp, text)
 
         return [
-            {"text": ent.text, "label": ent.label_, "start": ent.start_char, "end": ent.end_char}
+            {
+                "text": ent.text,
+                "label": ent.label_,
+                "start": ent.start_char,
+                "end": ent.end_char,
+            }
             for ent in doc.ents
         ]
 
-    @validate_input(LemmatizeSchema)
-
     async def lemmatize(self, text: str, language: Optional[str] = None) -> List[str]:
         """
         Lemmatize tokens in text using spaCy.
@@ -641,19 +641,14 @@ class ClassifierTool(BaseTool):
 
         language = language or self._detect_language(text)
 
-        nlp = await asyncio.get_event_loop().run_in_executor(
-            None, self._get_spacy, language
-        )
+        nlp = await asyncio.get_event_loop().run_in_executor(None, self._get_spacy, language)
 
-        doc = await asyncio.get_event_loop().run_in_executor(
-            None, nlp, text
-        )
+        doc = await asyncio.get_event_loop().run_in_executor(None, nlp, text)
 
-        # For Chinese, lemma might be the same as text, but spaCy handles it consistently
+        # For Chinese, lemma might be the same as text, but spaCy handles it
+        # consistently
         return [token.lemma_ for token in doc]
 
-    @validate_input(DependencyParseSchema)
-
     async def dependency_parse(self, text: str, language: Optional[str] = None) -> List[Dict[str, Any]]:
         """
         Perform dependency parsing using spaCy (supports both English and Chinese).
@@ -670,27 +665,27 @@ class ClassifierTool(BaseTool):
 
         language = language or self._detect_language(text)
 
-        nlp = await asyncio.get_event_loop().run_in_executor(
-            None, self._get_spacy, language
-        )
+        nlp = await asyncio.get_event_loop().run_in_executor(None, self._get_spacy, language)
 
-        doc = await asyncio.get_event_loop().run_in_executor(
-            None, nlp, text
-        )
+        doc = await asyncio.get_event_loop().run_in_executor(None, nlp, text)
 
         return [
             {
                 "text": token.text,
                 "head": token.head.text,
                 "dep": token.dep_,
-                "pos": token.pos_
+                "pos": token.pos_,
             }
             for token in doc
         ]
 
-    @validate_input(KeywordExtractSchema)
-
-    async def keyword_extract(self, text: str, top_k: int = 10, language: Optional[str] = None, extract_phrases: bool = True) -> List[str]:
+    async def keyword_extract(
+        self,
+        text: str,
+        top_k: int = 10,
+        language: Optional[str] = None,
+        extract_phrases: bool = True,
+    ) -> List[str]:
         """
         Extract keywords or key phrases from text using spaCy.
 
@@ -708,42 +703,28 @@ class ClassifierTool(BaseTool):
 
         language = language or self._detect_language(text)
 
-        if language == 'zh':
+        if language == "zh":
             if extract_phrases:
-                return await asyncio.get_event_loop().run_in_executor(
-                    None, self._extract_chinese_phrases, text, top_k
-                )
+                return await asyncio.get_event_loop().run_in_executor(None, self._extract_chinese_phrases, text, top_k)
             else:
                 # Extract simple keywords using spaCy
-                nlp = await asyncio.get_event_loop().run_in_executor(
-                    None, self._get_spacy, language
-                )
+                nlp = await asyncio.get_event_loop().run_in_executor(None, self._get_spacy, language)
 
-                doc = await asyncio.get_event_loop().run_in_executor(
-                    None, nlp, text
-                )
+                doc = await asyncio.get_event_loop().run_in_executor(None, nlp, text)
 
-                keywords = [token.text for token in doc if token.pos_ in ('NOUN', 'PROPN')][:top_k]
+                keywords = [token.text for token in doc if token.pos_ in ("NOUN", "PROPN")][:top_k]
                 return keywords
         else:  # English or other languages
             if extract_phrases and self.config.use_rake_for_english:
-                return await asyncio.get_event_loop().run_in_executor(
-                    None, self._extract_english_phrases, text, top_k
-                )
+                return await asyncio.get_event_loop().run_in_executor(None, self._extract_english_phrases, text, top_k)
             else:
-                nlp = await asyncio.get_event_loop().run_in_executor(
-                    None, self._get_spacy, language
-                )
+                nlp = await asyncio.get_event_loop().run_in_executor(None, self._get_spacy, language)
 
-                doc = await asyncio.get_event_loop().run_in_executor(
-                    None, nlp, text
-                )
+                doc = await asyncio.get_event_loop().run_in_executor(None, nlp, text)
 
-                keywords = [token.text for token in doc if token.pos_ in ('NOUN', 'PROPN')][:top_k]
+                keywords = [token.text for token in doc if token.pos_ in ("NOUN", "PROPN")][:top_k]
                 return keywords
 
-    @validate_input(SummarizeSchema)
-
     async def summarize(self, text: str, max_length: int = 150, language: Optional[str] = None) -> str:
         """
         Summarize text.
@@ -761,22 +742,21 @@ class ClassifierTool(BaseTool):
 
         language = language or self._detect_language(text)
         # Use appropriate models for summarization
-        if language == 'en':
+        if language == "en":
             model = "facebook/bart-large-cnn"
         else:
             # For Chinese and other languages, use a multilingual model
-            # For now, use t5-base, but consider using a Chinese-specific model in the future
+            # For now, use t5-base, but consider using a Chinese-specific model
+            # in the future
             model = "t5-base"
 
-        pipe = await asyncio.get_event_loop().run_in_executor(
-            None, self._get_hf_pipeline, "summarization", model
-        )
+        pipe = await asyncio.get_event_loop().run_in_executor(None, self._get_hf_pipeline, "summarization", model)
 
         # Different models use different parameter names for length control
         if model.startswith("t5"):
             # T5 models use max_new_tokens instead of max_length
             # For Chinese text, use a more conservative approach
-            if language == 'zh':
+            if language == "zh":
                 # Chinese text: use character count and be more conservative
                 input_chars = len(text)
                 max_new_tokens = min(max_length, max(input_chars // 4, 5))
@@ -786,13 +766,21 @@ class ClassifierTool(BaseTool):
                 input_words = len(text.split())
                 max_new_tokens = min(max_length, max(input_words // 2, 10))
                 min_new_tokens = 5
-            
+
             result = await asyncio.get_event_loop().run_in_executor(
-                None, lambda: pipe(text, max_new_tokens=max_new_tokens, min_new_tokens=min_new_tokens, do_sample=False)[0]['summary_text']
+                None,
+                lambda: pipe(
+                    text,
+                    max_new_tokens=max_new_tokens,
+                    min_new_tokens=min_new_tokens,
+                    do_sample=False,
+                )[
+                    0
+                ]["summary_text"],
             )
         else:
             # BART and other models use max_length
-            if language == 'zh':
+            if language == "zh":
                 # Chinese text: use character count
                 input_chars = len(text)
                 max_len = min(max_length, max(input_chars // 4, 10))
@@ -802,18 +790,30 @@ class ClassifierTool(BaseTool):
                 input_words = len(text.split())
                 max_len = min(max_length, max(input_words // 2, 20))
                 min_len = 10
-            
+
             result = await asyncio.get_event_loop().run_in_executor(
-                None, lambda: pipe(text, max_length=max_len, min_length=min_len, do_sample=False)[0]['summary_text']
+                None,
+                lambda: pipe(
+                    text,
+                    max_length=max_len,
+                    min_length=min_len,
+                    do_sample=False,
+                )[
+                    0
+                ]["summary_text"],
             )
 
         return result
 
-    @validate_input(BatchProcessSchema)
-
-    async def batch_process(self, texts: List[str], operation: str, language: Optional[str] = None,
-                           model: Optional[str] = None, top_k: Optional[int] = None,
-                           max_length: Optional[int] = None) -> List[Any]:
+    async def batch_process(
+        self,
+        texts: List[str],
+        operation: str,
+        language: Optional[str] = None,
+        model: Optional[str] = None,
+        top_k: Optional[int] = None,
+        max_length: Optional[int] = None,
+    ) -> List[Any]:
         """
         Process multiple texts with the specified operation.
 
@@ -834,7 +834,7 @@ class ClassifierTool(BaseTool):
         # Prepare operations to execute in batch
         operations = []
         for text in texts:
-            kwargs = {"text": text}
+            kwargs: Dict[str, Any] = {"text": text}
             if language:
                 kwargs["language"] = language
             if model and operation == "classify":
@@ -861,23 +861,24 @@ class ClassifierTool(BaseTool):
             "metrics": {
                 "requests": self._metrics["requests"],
                 "cache_hits": self._metrics["cache_hits"],
-                "avg_processing_time": sum(self._metrics["processing_time"]) / len(self._metrics["processing_time"])
-                                      if self._metrics["processing_time"] else 0.0
+                "avg_processing_time": (
+                    sum(float(t) for t in processing_times) / len(processing_times)
+                    if (processing_times := self._metrics.get("processing_time")) and isinstance(processing_times, list) and len(processing_times) > 0
+                    else 0.0
+                ),
             },
             "config": {
                 "max_workers": self.config.max_workers,
                 "pipeline_cache_size": self.config.pipeline_cache_size,
                 "rate_limit_enabled": self.config.rate_limit_enabled,
                 "rate_limit_requests": self.config.rate_limit_requests,
-                "rate_limit_window": self.config.rate_limit_window
-            }
+                "rate_limit_window": self.config.rate_limit_window,
+            },
         }
 
         # Check if models can be loaded
         try:
-            await asyncio.get_event_loop().run_in_executor(
-                None, self._get_spacy, "en"
-            )
+            await asyncio.get_event_loop().run_in_executor(None, self._get_spacy, "en")
             result["models"] = {"spacy_en": "ok"}
         except Exception as e:
             result["status"] = "warning"
@@ -893,7 +894,7 @@ class ClassifierTool(BaseTool):
         self._spacy_nlp.clear()
 
         # Clear metrics
-        self._metrics = {'requests': 0, 'cache_hits': 0, 'processing_time': []}
+        self._metrics = {"requests": 0, "cache_hits": 0, "processing_time": []}
 
         # Clear rate limiting data
         self._request_timestamps = []