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

aiecs/tools/task_tools/office_tool.py

@@ -20,31 +20,14 @@ from docx import Document as DocxDocument
 from docx.shared import Pt
 from pptx import Presentation
 from pptx.util import Inches
-from pydantic import BaseModel, field_validator, ValidationError, ConfigDict
-from pydantic_settings import BaseSettings
+from pydantic import BaseModel, field_validator, ValidationError, ConfigDict, Field
 
 from aiecs.tools.base_tool import BaseTool
 from aiecs.tools import register_tool
 
-# Configuration for OfficeTool
-class OfficeSettings(BaseSettings):
-    """
-    Configuration for OfficeTool.
-
-    Attributes:
-        max_file_size_mb (int): Maximum file size in megabytes.
-        default_font (str): Default font for documents.
-        default_font_size (int): Default font size in points.
-        allowed_extensions (List[str]): Allowed document file extensions.
-        env_prefix (str): Environment variable prefix for settings.
-    """
-    max_file_size_mb: int = 100
-    default_font: str = "Arial"
-    default_font_size: int = 12
-    allowed_extensions: List[str] = ['.docx', '.pptx', '.xlsx', '.pdf', '.png', '.jpg', '.jpeg', '.tiff', '.bmp', '.gif']
-    env_prefix: str = 'OFFICE_TOOL_'
-
-    model_config = ConfigDict(env_prefix='OFFICE_TOOL_')
+# Module-level default configuration for validators
+_DEFAULT_MAX_FILE_SIZE_MB = 100
+_DEFAULT_ALLOWED_EXTENSIONS = ['.docx', '.pptx', '.xlsx', '.pdf', '.png', '.jpg', '.jpeg', '.tiff', '.bmp', '.gif']
 
 # Exceptions
 class OfficeToolError(Exception):
@@ -78,7 +61,6 @@ class BaseFileSchema(BaseModel):
         """Validate file paths for existence, size, extension, and path traversal."""
         if not v:
             return v
-        settings = OfficeSettings()
         abs_path = os.path.abspath(os.path.normpath(v))
         # Check for path traversal
         if '..' in v or '~' in v or '%' in v:
@@ -90,15 +72,15 @@ class BaseFileSchema(BaseModel):
             raise SecurityError(f"Path not in allowed directories: {abs_path}")
         # Check extension
         ext = os.path.splitext(abs_path)[1].lower()
-        if ext not in settings.allowed_extensions:
-            raise SecurityError(f"Extension '{ext}' not allowed for '{field.field_name}', expected {settings.allowed_extensions}")
+        if ext not in _DEFAULT_ALLOWED_EXTENSIONS:
+            raise SecurityError(f"Extension '{ext}' not allowed for '{field.field_name}', expected {_DEFAULT_ALLOWED_EXTENSIONS}")
         # Check file existence and size for input paths
         if field.field_name == 'file_path':
             if not os.path.isfile(abs_path):
                 raise FileOperationError(f"{field.field_name}: File not found: {abs_path}")
             size_mb = os.path.getsize(abs_path) / (1024 * 1024)
-            if size_mb > settings.max_file_size_mb:
-                raise FileOperationError(f"{field.field_name}: File too large: {size_mb:.1f}MB, max {settings.max_file_size_mb}MB")
+            if size_mb > _DEFAULT_MAX_FILE_SIZE_MB:
+                raise FileOperationError(f"{field.field_name}: File too large: {size_mb:.1f}MB, max {_DEFAULT_MAX_FILE_SIZE_MB}MB")
         # Check for existing output paths
         elif field.field_name == 'output_path' and os.path.exists(abs_path):
             raise FileOperationError(f"{field.field_name}: File already exists: {abs_path}")
@@ -155,23 +137,44 @@ class OfficeTool(BaseTool):
 
     Inherits from BaseTool to leverage ToolExecutor for caching, concurrency, and error handling.
     """
+    
+    # Configuration schema
+    class Config(BaseModel):
+        """Configuration for the office tool"""
+        model_config = ConfigDict(env_prefix="OFFICE_TOOL_")
+        
+        max_file_size_mb: int = Field(
+            default=100,
+            description="Maximum file size in megabytes"
+        )
+        default_font: str = Field(
+            default="Arial",
+            description="Default font for documents"
+        )
+        default_font_size: int = Field(
+            default=12,
+            description="Default font size in points"
+        )
+        allowed_extensions: List[str] = Field(
+            default=['.docx', '.pptx', '.xlsx', '.pdf', '.png', '.jpg', '.jpeg', '.tiff', '.bmp', '.gif'],
+            description="Allowed document file extensions"
+        )
+    
     def __init__(self, config: Optional[Dict[str, Any]] = None):
         """
-        Initialize OfficeTool with settings.
+        Initialize OfficeTool with configuration.
 
         Args:
-            config (Dict, optional): Configuration overrides for OfficeSettings.
+            config (Dict, optional): Configuration overrides for OfficeTool.
 
         Raises:
             ValueError: If config contains invalid settings.
         """
         super().__init__(config)
-        self.settings = OfficeSettings()
-        if config:
-            try:
-                self.settings = self.settings.model_validate({**self.settings.model_dump(), **config})
-            except ValidationError as e:
-                raise ValueError(f"Invalid configuration: {e}")
+        
+        # Parse configuration
+        self.config = self.Config(**(config or {}))
+        
         self.logger = logging.getLogger(__name__)
         if not self.logger.handlers:
             handler = logging.StreamHandler()
@@ -385,8 +388,8 @@ class OfficeTool(BaseTool):
             sanitized_table_data = self._sanitize_table_data(table_data)
             doc = DocxDocument()
             style = doc.styles['Normal']
-            style.font.name = self.settings.default_font
-            style.font.size = Pt(self.settings.default_font_size)
+            style.font.name = self.config.default_font
+            style.font.size = Pt(self.config.default_font_size)
             for line in sanitized_text.splitlines():
                 doc.add_paragraph(line)
             if sanitized_table_data and sanitized_table_data[0]:

aiecs/tools/task_tools/pandas_tool.py

@@ -2,7 +2,7 @@ from io import StringIO
 import pandas as pd
 import numpy as np
 from typing import List, Dict, Union, Optional, Any
-from pydantic import BaseModel, ValidationError as PydanticValidationError, ConfigDict
+from pydantic import BaseModel, ValidationError as PydanticValidationError, ConfigDict, Field
 import logging
 
 from aiecs.tools.base_tool import BaseTool
@@ -29,31 +29,6 @@ class ValidationError(PandasToolError):
     """Validation error."""
     pass
 
-# Configuration for PandasTool
-class PandasToolConfig(BaseModel):
-    """
-    Configuration for PandasTool.
-
-    Attributes:
-        csv_delimiter (str): Delimiter for CSV files.
-        encoding (str): Encoding for file operations.
-        default_agg (Dict[str, str]): Default aggregation functions.
-        chunk_size (int): Chunk size for large file processing.
-        max_csv_size (int): Threshold for chunked CSV processing.
-        allowed_file_extensions (List[str]): Allowed file extensions.
-        env_prefix (str): Environment variable prefix.
-    """
-    csv_delimiter: str = ","
-    encoding: str = "utf-8"
-    default_agg: Dict[str, str] = {"numeric": "mean", "object": "count"}
-    chunk_size: int = 10000
-    max_csv_size: int = 1000000
-    allowed_file_extensions: List[str] = ['.csv', '.xlsx', '.json']
-    env_prefix: str = "PANDAS_TOOL_"
-
-    model_config = ConfigDict(env_prefix="PANDAS_TOOL_")
-
-
 @register_tool("pandas")
 class PandasTool(BaseTool):
     """
@@ -72,23 +47,52 @@ class PandasTool(BaseTool):
 
     Inherits from BaseTool to leverage ToolExecutor for caching, concurrency, and error handling.
     """
+    
+    # Configuration schema
+    class Config(BaseModel):
+        """Configuration for the pandas tool"""
+        model_config = ConfigDict(env_prefix="PANDAS_TOOL_")
+        
+        csv_delimiter: str = Field(
+            default=",",
+            description="Delimiter for CSV files"
+        )
+        encoding: str = Field(
+            default="utf-8",
+            description="Encoding for file operations"
+        )
+        default_agg: Dict[str, str] = Field(
+            default={"numeric": "mean", "object": "count"},
+            description="Default aggregation functions"
+        )
+        chunk_size: int = Field(
+            default=10000,
+            description="Chunk size for large file processing"
+        )
+        max_csv_size: int = Field(
+            default=1000000,
+            description="Threshold for chunked CSV processing"
+        )
+        allowed_file_extensions: List[str] = Field(
+            default=['.csv', '.xlsx', '.json'],
+            description="Allowed file extensions"
+        )
+    
     def __init__(self, config: Optional[Dict] = None):
         """
         Initialize PandasTool with configuration.
 
         Args:
-            config (Dict, optional): Configuration overrides for PandasToolConfig.
+            config (Dict, optional): Configuration overrides for PandasTool.
 
         Raises:
             ValueError: If config is invalid.
         """
         super().__init__(config)
-        self.config = PandasToolConfig()
-        if config:
-            try:
-                self.config = self.config.model_validate({**self.config.model_dump(), **config})
-            except PydanticValidationError as e:
-                raise ValueError(f"Invalid configuration: {e}")
+        
+        # Parse configuration
+        self.config = self.Config(**(config or {}))
+        
         self.logger = logging.getLogger(__name__)
         if not self.logger.handlers:
             handler = logging.StreamHandler()

aiecs/tools/task_tools/report_tool.py

@@ -19,8 +19,7 @@ from docx import Document
 from docx.shared import Pt as DocxPt, RGBColor
 import markdown
 import matplotlib.pyplot as plt
-from pydantic import ValidationError, ConfigDict
-from pydantic_settings import BaseSettings
+from pydantic import ValidationError, ConfigDict, Field
 import tempfile
 import logging
 
@@ -28,45 +27,6 @@ from aiecs.tools.base_tool import BaseTool
 from aiecs.tools import register_tool
 from aiecs.tools.temp_file_manager import TempFileManager
 
-# Configuration for ReportTool
-class ReportSettings(BaseSettings):
-    """
-    Configuration for ReportTool.
-
-    Attributes:
-        templates_dir (str): Directory for Jinja2 templates.
-        default_output_dir (str): Default directory for output files.
-        allowed_extensions (List[str]): Allowed file extensions for outputs.
-        pdf_page_size (str): Default PDF page size.
-        default_font (str): Default font for documents.
-        default_font_size (int): Default font size in points.
-        allowed_html_tags (Set[str]): Allowed HTML tags for sanitization.
-        allowed_html_attributes (Dict[str, List[str]]): Allowed HTML attributes for sanitization.
-        temp_files_max_age (int): Maximum age of temporary files in seconds.
-        env_prefix (str): Environment variable prefix for settings.
-    """
-    templates_dir: str = os.getcwd()
-    default_output_dir: str = os.path.join(tempfile.gettempdir(), 'reports')
-    allowed_extensions: List[str] = ['.html', '.pdf', '.xlsx', '.pptx', '.docx', '.md', '.png']
-    pdf_page_size: str = 'A4'
-    default_font: str = 'Arial'
-    default_font_size: int = 12
-    allowed_html_tags: Set[str] = {
-        'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'br', 'a', 'ul', 'ol', 'li',
-        'strong', 'em', 'b', 'i', 'table', 'tr', 'td', 'th', 'thead', 'tbody',
-        'span', 'div', 'img', 'hr', 'code', 'pre'
-    }
-    allowed_html_attributes: Dict[str, List[str]] = {
-        'a': ['href', 'title', 'target'],
-        'img': ['src', 'alt', 'title', 'width', 'height'],
-        'td': ['colspan', 'rowspan', 'align'],
-        'th': ['colspan', 'rowspan', 'align'],
-        '*': ['class', 'id', 'style']
-    }
-    temp_files_max_age: int = 3600  # 1 hour in seconds
-    env_prefix: str = 'REPORT_TOOL_'
-
-    model_config = ConfigDict(env_prefix='REPORT_TOOL_')
 
 # Exceptions
 class ReportToolError(Exception):
@@ -119,23 +79,74 @@ class ReportTool(BaseTool):
 
     Inherits from BaseTool.
     """
+    
+    # Configuration schema
+    class Config(BaseModel):
+        """Configuration for the report tool"""
+        model_config = ConfigDict(env_prefix="REPORT_TOOL_")
+        
+        templates_dir: str = Field(
+            default=os.getcwd(),
+            description="Directory for Jinja2 templates"
+        )
+        default_output_dir: str = Field(
+            default=os.path.join(tempfile.gettempdir(), 'reports'),
+            description="Default directory for output files"
+        )
+        allowed_extensions: List[str] = Field(
+            default=['.html', '.pdf', '.xlsx', '.pptx', '.docx', '.md', '.png'],
+            description="Allowed file extensions for outputs"
+        )
+        pdf_page_size: str = Field(
+            default='A4',
+            description="Default PDF page size"
+        )
+        default_font: str = Field(
+            default='Arial',
+            description="Default font for documents"
+        )
+        default_font_size: int = Field(
+            default=12,
+            description="Default font size in points"
+        )
+        allowed_html_tags: Set[str] = Field(
+            default={
+                'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'p', 'br', 'a', 'ul', 'ol', 'li',
+                'strong', 'em', 'b', 'i', 'table', 'tr', 'td', 'th', 'thead', 'tbody',
+                'span', 'div', 'img', 'hr', 'code', 'pre'
+            },
+            description="Allowed HTML tags for sanitization"
+        )
+        allowed_html_attributes: Dict[str, List[str]] = Field(
+            default={
+                'a': ['href', 'title', 'target'],
+                'img': ['src', 'alt', 'title', 'width', 'height'],
+                'td': ['colspan', 'rowspan', 'align'],
+                'th': ['colspan', 'rowspan', 'align'],
+                '*': ['class', 'id', 'style']
+            },
+            description="Allowed HTML attributes for sanitization"
+        )
+        temp_files_max_age: int = Field(
+            default=3600,
+            description="Maximum age of temporary files in seconds"
+        )
+    
     def __init__(self, config: Optional[Dict[str, Any]] = None):
         """
         Initialize ReportTool with settings and resources.
 
         Args:
-            config (Dict, optional): Configuration overrides for ReportSettings.
+            config (Dict, optional): Configuration overrides for ReportTool.
 
         Raises:
             ValueError: If config contains invalid settings.
         """
         super().__init__(config)
-        self.settings = ReportSettings()
-        if config:
-            try:
-                self.settings = self.settings.model_validate({**self.settings.model_dump(), **config})
-            except ValidationError as e:
-                raise ValueError(f"Invalid configuration: {e}")
+        
+        # Parse configuration
+        self.config = self.Config(**(config or {}))
+        
         self.logger = logging.getLogger(__name__)
         if not self.logger.handlers:
             handler = logging.StreamHandler()
@@ -143,10 +154,10 @@ class ReportTool(BaseTool):
             self.logger.addHandler(handler)
         self.logger.setLevel(logging.INFO)
         self._jinja_env = sandbox.SandboxedEnvironment(
-            loader=FileSystemLoader(self.settings.templates_dir),
+            loader=FileSystemLoader(self.config.templates_dir),
             autoescape=True
         )
-        self._temp_manager = TempFileManager(self.settings.default_output_dir, self.settings.temp_files_max_age)
+        self._temp_manager = TempFileManager(self.config.default_output_dir, self.config.temp_files_max_age)
 
     def generate_html(self, template_path: Optional[str], template_str: Optional[str], context: Dict[str, Any], output_path: str, template_variables: Optional[Dict[str, str]] = None) -> str:
         """
@@ -167,7 +178,7 @@ class ReportTool(BaseTool):
         """
         try:
             if template_path:
-                path = os.path.join(self.settings.templates_dir, template_path)
+                path = os.path.join(self.config.templates_dir, template_path)
                 tmpl = self._jinja_env.get_template(template_path)
             else:
                 tmpl = self._jinja_env.from_string(template_str)
@@ -178,7 +189,7 @@ class ReportTool(BaseTool):
                 html = html.replace('<head>', '<head>\n' + csrf_meta)
             else:
                 html = csrf_meta + html
-            html = sanitize_html(html, self.settings.allowed_html_tags, self.settings.allowed_html_attributes)
+            html = sanitize_html(html, self.config.allowed_html_tags, self.config.allowed_html_attributes)
             with open(output_path, 'w', encoding='utf-8') as f:
                 f.write(html)
             self._temp_manager.register_file(output_path)
@@ -290,8 +301,8 @@ class ReportTool(BaseTool):
                 s = prs.slides.add_slide(prs.slide_layouts[1])
                 title_shape = s.shapes.title
                 title_shape.text = slide['title']
-                font = slide.get('font') or default_font or self.settings.default_font
-                font_size = slide.get('font_size') or default_font_size or self.settings.default_font_size
+                font = slide.get('font') or default_font or self.config.default_font
+                font_size = slide.get('font_size') or default_font_size or self.config.default_font_size
                 font_color = slide.get('font_color') or default_font_color or (0, 0, 0)
                 title_shape.text_frame.paragraphs[0].font.name = font
                 title_shape.text_frame.paragraphs[0].font.size = Pt(font_size)
@@ -370,8 +381,8 @@ class ReportTool(BaseTool):
                 tmpl = self._jinja_env.from_string(template_str)
             content = tmpl.render(**context)
             doc = Document()
-            font = font or self.settings.default_font
-            font_size = font_size or self.settings.default_font_size
+            font = font or self.config.default_font
+            font_size = font_size or self.config.default_font_size
             font_color = font_color or (0, 0, 0)
             for line in content.splitlines():
                 p = doc.add_paragraph()

aiecs/tools/task_tools/research_tool.py

@@ -2,8 +2,7 @@ import logging
 from typing import Dict, Any, List, Optional, Tuple
 import spacy
 from spacy.language import Language
-from pydantic import BaseModel, ValidationError, ConfigDict
-from pydantic_settings import BaseSettings
+from pydantic import BaseModel, ValidationError, ConfigDict, Field
 from collections import Counter
 from scipy.stats import pearsonr
 import os
@@ -11,25 +10,6 @@ import os
 from aiecs.tools.base_tool import BaseTool
 from aiecs.tools import register_tool
 
-# Configuration for ResearchTool
-class ResearchSettings(BaseSettings):
-    """
-    Configuration for ResearchTool.
-
-    Attributes:
-        max_workers (int): Maximum number of thread pool workers.
-        spacy_model (str): Default spaCy model to use.
-        max_text_length (int): Maximum text length for inputs.
-        allowed_spacy_models (List[str]): Allowed spaCy models.
-        env_prefix (str): Environment variable prefix.
-    """
-    max_workers: int = min(32, (os.cpu_count() or 4) * 2)
-    spacy_model: str = "en_core_web_sm"
-    max_text_length: int = 10_000
-    allowed_spacy_models: List[str] = ["en_core_web_sm", "zh_core_web_sm"]
-    env_prefix: str = 'RESEARCH_TOOL_'
-
-    model_config = ConfigDict(env_prefix='RESEARCH_TOOL_')
 
 # Exceptions
 class ResearchToolError(Exception):
@@ -57,23 +37,44 @@ class ResearchTool(BaseTool):
 
     Inherits from BaseTool.
     """
+    
+    # Configuration schema
+    class Config(BaseModel):
+        """Configuration for the research tool"""
+        model_config = ConfigDict(env_prefix="RESEARCH_TOOL_")
+        
+        max_workers: int = Field(
+            default=min(32, (os.cpu_count() or 4) * 2),
+            description="Maximum number of worker threads"
+        )
+        spacy_model: str = Field(
+            default="en_core_web_sm",
+            description="Default spaCy model to use"
+        )
+        max_text_length: int = Field(
+            default=10_000,
+            description="Maximum text length for inputs"
+        )
+        allowed_spacy_models: List[str] = Field(
+            default=["en_core_web_sm", "zh_core_web_sm"],
+            description="Allowed spaCy models"
+        )
+    
     def __init__(self, config: Optional[Dict[str, Any]] = None):
         """
         Initialize ResearchTool with settings and resources.
 
         Args:
-            config (Dict, optional): Configuration overrides for ResearchSettings.
+            config (Dict, optional): Configuration overrides for ResearchTool.
 
         Raises:
             ValueError: If config contains invalid settings.
         """
         super().__init__(config)
-        self.settings = ResearchSettings()
-        if config:
-            try:
-                self.settings = self.settings.model_validate({**self.settings.model_dump(), **config})
-            except ValidationError as e:
-                raise ValueError(f"Invalid configuration: {e}")
+        
+        # Parse configuration
+        self.config = self.Config(**(config or {}))
+        
         self.logger = logging.getLogger(__name__)
         if not self.logger.handlers:
             handler = logging.StreamHandler()
@@ -98,9 +99,9 @@ class ResearchTool(BaseTool):
             ResearchToolError: If the spaCy model is invalid.
         """
         if self._spacy_nlp is None:
-            if self.settings.spacy_model not in self.settings.allowed_spacy_models:
-                raise ResearchToolError(f"Invalid spaCy model '{self.settings.spacy_model}', expected {self.settings.allowed_spacy_models}")
-            self._spacy_nlp = spacy.load(self.settings.spacy_model, disable=["textcat"])
+            if self.config.spacy_model not in self.config.allowed_spacy_models:
+                raise ResearchToolError(f"Invalid spaCy model '{self.config.spacy_model}', expected {self.config.allowed_spacy_models}")
+            self._spacy_nlp = spacy.load(self.config.spacy_model, disable=["textcat"])
         return self._spacy_nlp
 
     def mill_agreement(self, cases: List[Dict[str, Any]]) -> Dict[str, Any]: