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

aiecs/tools/docs/ai_document_orchestrator.py

@@ -6,7 +6,6 @@ from enum import Enum
 from datetime import datetime
 
 from pydantic import BaseModel, Field, ValidationError, ConfigDict
-from pydantic_settings import BaseSettings
 
 from aiecs.tools.base_tool import BaseTool
 from aiecs.tools import register_tool
@@ -31,16 +30,6 @@ class AIProvider(str, Enum):
     LOCAL = "local"
 
 
-class OrchestratorSettings(BaseSettings):
-    """Configuration for AI Document Orchestrator"""
-    default_ai_provider: AIProvider = AIProvider.OPENAI
-    max_chunk_size: int = 4000  # For AI processing
-    max_concurrent_requests: int = 5
-    default_temperature: float = 0.1
-    max_tokens: int = 2000
-    timeout: int = 60
-    
-    model_config = ConfigDict(env_prefix="AI_DOC_ORCHESTRATOR_")
 
 
 class AIDocumentOrchestratorError(Exception):
@@ -73,18 +62,42 @@ class AIDocumentOrchestrator(BaseTool):
     - Existing AIECS infrastructure
     """
     
+    # Configuration schema
+    class Config(BaseModel):
+        """Configuration for the AI document orchestrator tool"""
+        model_config = ConfigDict(env_prefix="AI_DOC_ORCHESTRATOR_")
+        
+        default_ai_provider: str = Field(
+            default="openai",
+            description="Default AI provider to use"
+        )
+        max_chunk_size: int = Field(
+            default=4000,
+            description="Maximum chunk size for AI processing"
+        )
+        max_concurrent_requests: int = Field(
+            default=5,
+            description="Maximum concurrent AI requests"
+        )
+        default_temperature: float = Field(
+            default=0.1,
+            description="Default temperature for AI model"
+        )
+        max_tokens: int = Field(
+            default=2000,
+            description="Maximum tokens for AI response"
+        )
+        timeout: int = Field(
+            default=60,
+            description="Timeout in seconds for AI operations"
+        )
+    
     def __init__(self, config: Optional[Dict] = None):
         """Initialize AI Document Orchestrator with settings"""
         super().__init__(config)
-        # Initialize settings with config if provided
-        if config:
-            try:
-                # For BaseSettings, use dictionary unpacking
-                self.settings = OrchestratorSettings(**config)
-            except ValidationError as e:
-                raise ValueError(f"Invalid settings: {e}")
-        else:
-            self.settings = OrchestratorSettings()
+        
+        # Parse configuration
+        self.config = self.Config(**(config or {}))
         
         self.logger = logging.getLogger(__name__)
         
@@ -212,7 +225,7 @@ class AIDocumentOrchestrator(BaseTool):
             ai_result = self._process_with_ai(
                 content, 
                 processing_mode, 
-                ai_provider or self.settings.default_ai_provider,
+                ai_provider or self.config.default_ai_provider,
                 processing_params or {},
                 ai_params or {}
             )
@@ -221,7 +234,7 @@ class AIDocumentOrchestrator(BaseTool):
             result = {
                 "source": source,
                 "processing_mode": processing_mode,
-                "ai_provider": ai_provider or self.settings.default_ai_provider,
+                "ai_provider": ai_provider or self.config.default_ai_provider,
                 "document_info": {
                     "type": parsed_result.get("document_type"),
                     "detection_confidence": parsed_result.get("detection_confidence"),
@@ -282,7 +295,7 @@ class AIDocumentOrchestrator(BaseTool):
         """
         try:
             start_time = datetime.now()
-            max_concurrent = max_concurrent or self.settings.max_concurrent_requests
+            max_concurrent = max_concurrent or self.config.max_concurrent_requests
             
             # Process documents in batches
             results = asyncio.run(self._batch_process_async(
@@ -293,7 +306,7 @@ class AIDocumentOrchestrator(BaseTool):
             batch_result = {
                 "sources": sources,
                 "processing_mode": processing_mode,
-                "ai_provider": ai_provider or self.settings.default_ai_provider,
+                "ai_provider": ai_provider or self.config.default_ai_provider,
                 "total_documents": len(sources),
                 "successful_documents": len([r for r in results if r.get("status") == "success"]),
                 "failed_documents": len([r for r in results if r.get("status") == "error"]),
@@ -341,7 +354,7 @@ class AIDocumentOrchestrator(BaseTool):
             # Process with AI
             ai_result = self._call_ai_provider(
                 prompt,
-                ai_provider or self.settings.default_ai_provider,
+                ai_provider or self.config.default_ai_provider,
                 {}
             )
             
@@ -380,7 +393,7 @@ class AIDocumentOrchestrator(BaseTool):
             text_content = str(content)
         
         # Chunk content if too large
-        max_size = self.settings.max_chunk_size
+        max_size = self.config.max_chunk_size
         if len(text_content) > max_size:
             # For now, truncate - could implement smart chunking
             text_content = text_content[:max_size] + "\n\n[Content truncated...]"

aiecs/tools/docs/ai_document_writer_orchestrator.py

@@ -6,8 +6,7 @@ from typing import Dict, Any, List, Optional, Union, Callable
 from enum import Enum
 from datetime import datetime
 
-from pydantic import BaseModel, Field, ValidationError
-from pydantic_settings import BaseSettings
+from pydantic import BaseModel, Field, ValidationError, ConfigDict
 
 from aiecs.tools.base_tool import BaseTool
 from aiecs.tools import register_tool
@@ -52,25 +51,6 @@ class AIProvider(str, Enum):
     LOCAL = "local"
 
 
-class WriterOrchestratorSettings(BaseSettings):
-    """Configuration for AI Document Writer Orchestrator"""
-    default_ai_provider: AIProvider = AIProvider.OPENAI
-    max_content_length: int = 50000  # Maximum content length for AI generation
-    max_concurrent_writes: int = 5
-    default_temperature: float = 0.3
-    max_tokens: int = 4000
-    timeout: int = 60
-    
-    # Draft and review settings
-    enable_draft_mode: bool = True
-    enable_content_review: bool = True
-    auto_backup_on_ai_write: bool = True
-    
-    # Directory settings
-    temp_dir: str = tempfile.gettempdir()
-    
-    class Config:
-        env_prefix = "AI_DOC_WRITER_"
 
 
 class AIDocumentWriterOrchestratorError(Exception):
@@ -104,15 +84,58 @@ class AIDocumentWriterOrchestrator(BaseTool):
     - Existing AIECS infrastructure
     """
     
+    # Configuration schema
+    class Config(BaseModel):
+        """Configuration for the AI document writer orchestrator tool"""
+        model_config = ConfigDict(env_prefix="AI_DOC_WRITER_")
+        
+        default_ai_provider: str = Field(
+            default="openai",
+            description="Default AI provider to use"
+        )
+        max_content_length: int = Field(
+            default=50000,
+            description="Maximum content length for AI generation"
+        )
+        max_concurrent_writes: int = Field(
+            default=5,
+            description="Maximum concurrent write operations"
+        )
+        default_temperature: float = Field(
+            default=0.3,
+            description="Default temperature for AI model"
+        )
+        max_tokens: int = Field(
+            default=4000,
+            description="Maximum tokens for AI response"
+        )
+        timeout: int = Field(
+            default=60,
+            description="Timeout in seconds for AI operations"
+        )
+        enable_draft_mode: bool = Field(
+            default=True,
+            description="Whether to enable draft mode"
+        )
+        enable_content_review: bool = Field(
+            default=True,
+            description="Whether to enable content review"
+        )
+        auto_backup_on_ai_write: bool = Field(
+            default=True,
+            description="Whether to automatically backup before AI writes"
+        )
+        temp_dir: str = Field(
+            default=tempfile.gettempdir(),
+            description="Temporary directory for processing"
+        )
+    
     def __init__(self, config: Optional[Dict] = None):
         """Initialize AI Document Writer Orchestrator with settings"""
         super().__init__(config)
-        self.settings = WriterOrchestratorSettings()
-        if config:
-            try:
-                self.settings = self.settings.model_validate({**self.settings.model_dump(), **config})
-            except ValidationError as e:
-                raise ValueError(f"Invalid settings: {e}")
+        
+        # Parse configuration
+        self.config = self.Config(**(config or {}))
         
         self.logger = logging.getLogger(__name__)
         
@@ -328,7 +351,7 @@ class AIDocumentWriterOrchestrator(BaseTool):
                 content_requirements,
                 generation_mode,
                 document_format,
-                ai_provider or self.settings.default_ai_provider,
+                ai_provider or self.config.default_ai_provider,
                 generation_params or {}
             )
             
@@ -363,7 +386,7 @@ class AIDocumentWriterOrchestrator(BaseTool):
                 "generation_mode": generation_mode,
                 "document_format": document_format,
                 "write_strategy": write_strategy,
-                "ai_provider": ai_provider or self.settings.default_ai_provider,
+                "ai_provider": ai_provider or self.config.default_ai_provider,
                 "ai_result": ai_result,
                 "write_result": write_result,
                 "post_process_result": post_process_result,
@@ -431,14 +454,14 @@ class AIDocumentWriterOrchestrator(BaseTool):
             ai_result = self._enhance_content_with_ai(
                 existing_content,
                 enhancement_goals,
-                ai_provider or self.settings.default_ai_provider
+                ai_provider or self.config.default_ai_provider
             )
             
             # Step 3: Write enhanced content
             target = target_path or source_path
             write_mode = "overwrite" if target == source_path else "create"
             
-            if self.settings.auto_backup_on_ai_write and target == source_path:
+            if self.config.auto_backup_on_ai_write and target == source_path:
                 write_mode = "backup_write"
             
             write_result = self.document_writer.write_document(
@@ -486,7 +509,7 @@ class AIDocumentWriterOrchestrator(BaseTool):
         try:
             start_time = datetime.now()
             batch_id = f"batch_ai_write_{int(start_time.timestamp())}"
-            max_concurrent = max_concurrent or self.settings.max_concurrent_writes
+            max_concurrent = max_concurrent or self.config.max_concurrent_writes
             
             self.logger.info(f"Starting batch AI write {batch_id}: {len(write_requests)} requests")
             
@@ -568,7 +591,7 @@ class AIDocumentWriterOrchestrator(BaseTool):
                 edit_operation,
                 edit_instructions,
                 analysis_result,
-                ai_provider or self.settings.default_ai_provider
+                ai_provider or self.config.default_ai_provider
             )
             
             # Step 4: Execute editing operations
@@ -1454,7 +1477,7 @@ Please provide a detailed editing plan with:
                         item.get('requirements', ''),
                         ContentGenerationMode.GENERATE,
                         'markdown',
-                        self.settings.default_ai_provider,
+                        self.config.default_ai_provider,
                         item.get('generation_params', {})
                     )
                     
@@ -1634,7 +1657,7 @@ Please provide a detailed editing plan with:
                 analysis_prompt,
                 ContentGenerationMode.GENERATE,
                 'markdown',
-                self.settings.default_ai_provider,
+                self.config.default_ai_provider,
                 {}
             )
             
@@ -1781,7 +1804,7 @@ Please provide a detailed editing plan with:
         """
         try:
             # Load template
-            template_file = os.path.join(self.settings.temp_dir, f"template_{template_name}.json")
+            template_file = os.path.join(self.config.temp_dir, f"template_{template_name}.json")
             with open(template_file, 'r') as f:
                 import json
                 template_info = json.load(f)
@@ -1798,7 +1821,7 @@ Please provide a detailed editing plan with:
                     f"Template: {template_name}",
                     ContentGenerationMode.TEMPLATE_FILL,
                     "txt",
-                    self.settings.default_ai_provider,
+                    self.config.default_ai_provider,
                     {
                         "template": template_info["content"],
                         "data": template_data
@@ -2189,7 +2212,7 @@ Please provide a detailed editing plan with:
         
         # Log operation
         try:
-            log_file = os.path.join(self.settings.temp_dir, "ai_write_operations.log")
+            log_file = os.path.join(self.config.temp_dir, "ai_write_operations.log")
             with open(log_file, "a") as f:
                 import json
                 f.write(json.dumps(post_process_info) + "\n")

aiecs/tools/docs/content_insertion_tool.py

@@ -24,8 +24,7 @@ from typing import Dict, Any, List, Optional, Union, Tuple
 from enum import Enum
 from pathlib import Path
 
-from pydantic import BaseModel, Field, ValidationError
-from pydantic_settings import BaseSettings
+from pydantic import BaseModel, Field, ValidationError, ConfigDict
 
 from aiecs.tools.base_tool import BaseTool
 from aiecs.tools import register_tool
@@ -97,18 +96,6 @@ class InsertionPosition(str, Enum):
     INLINE = "inline"
 
 
-class ContentInsertionSettings(BaseSettings):
-    """Configuration for ContentInsertionTool"""
-    temp_dir: str = os.path.join(tempfile.gettempdir(), 'content_insertion')
-    assets_dir: str = os.path.join(tempfile.gettempdir(), 'document_assets')
-    max_image_size: int = 10 * 1024 * 1024  # 10MB
-    max_chart_size: Tuple[int, int] = (1200, 800)  # pixels
-    default_image_format: str = "png"
-    optimize_images: bool = True
-    auto_resize: bool = True
-    
-    class Config:
-        env_prefix = "CONTENT_INSERT_"
 
 
 class ContentInsertionError(Exception):
@@ -151,13 +138,46 @@ class ContentInsertionTool(BaseTool):
     - DocumentWriterTool for content placement
     """
     
+    # Configuration schema
+    class Config(BaseModel):
+        """Configuration for the content insertion tool"""
+        model_config = ConfigDict(env_prefix="CONTENT_INSERT_")
+        
+        temp_dir: str = Field(
+            default=os.path.join(tempfile.gettempdir(), 'content_insertion'),
+            description="Temporary directory for content processing"
+        )
+        assets_dir: str = Field(
+            default=os.path.join(tempfile.gettempdir(), 'document_assets'),
+            description="Directory for document assets"
+        )
+        max_image_size: int = Field(
+            default=10 * 1024 * 1024,
+            description="Maximum image size in bytes"
+        )
+        max_chart_size: Tuple[int, int] = Field(
+            default=(1200, 800),
+            description="Maximum chart size in pixels (width, height)"
+        )
+        default_image_format: str = Field(
+            default="png",
+            description="Default image format for generated content"
+        )
+        optimize_images: bool = Field(
+            default=True,
+            description="Whether to optimize images automatically"
+        )
+        auto_resize: bool = Field(
+            default=True,
+            description="Whether to automatically resize content to fit"
+        )
+    
     def __init__(self, config: Optional[Dict] = None):
         """Initialize Content Insertion Tool with settings"""
         super().__init__(config)
-        try:
-            self.settings = ContentInsertionSettings(**(config or {}))
-        except ValidationError as e:
-            raise ValueError(f"Invalid settings: {e}")
+        
+        # Parse configuration
+        self.config = self.Config(**(config or {}))
         
         self.logger = logging.getLogger(__name__)
         
@@ -175,8 +195,8 @@ class ContentInsertionTool(BaseTool):
     
     def _init_directories(self):
         """Initialize required directories"""
-        os.makedirs(self.settings.temp_dir, exist_ok=True)
-        os.makedirs(self.settings.assets_dir, exist_ok=True)
+        os.makedirs(self.config.temp_dir, exist_ok=True)
+        os.makedirs(self.config.assets_dir, exist_ok=True)
     
     def _init_external_tools(self):
         """Initialize external tools for content generation"""
@@ -803,14 +823,14 @@ class ContentInsertionTool(BaseTool):
                 raise ChartInsertionError("Chart file not found")
             
             # Copy chart to assets directory
-            chart_filename = f"chart_{uuid.uuid4().hex[:8]}.{self.settings.default_image_format}"
-            asset_path = os.path.join(self.settings.assets_dir, chart_filename)
+            chart_filename = f"chart_{uuid.uuid4().hex[:8]}.{self.config.default_image_format}"
+            asset_path = os.path.join(self.config.assets_dir, chart_filename)
             
             import shutil
             shutil.copy2(chart_file, asset_path)
             
             # Optimize if needed
-            if self.settings.optimize_images and 'image' in self.external_tools:
+            if self.config.optimize_images and 'image' in self.external_tools:
                 self._optimize_image(asset_path)
             
             return {
@@ -878,8 +898,8 @@ class ContentInsertionTool(BaseTool):
                 image_file = image_source
             
             # Copy to assets directory
-            image_filename = f"image_{uuid.uuid4().hex[:8]}.{self.settings.default_image_format}"
-            asset_path = os.path.join(self.settings.assets_dir, image_filename)
+            image_filename = f"image_{uuid.uuid4().hex[:8]}.{self.config.default_image_format}"
+            asset_path = os.path.join(self.config.assets_dir, image_filename)
             
             import shutil
             shutil.copy2(image_file, asset_path)
@@ -1142,8 +1162,8 @@ class ContentInsertionTool(BaseTool):
         """Download image from URL"""
         import urllib.request
         
-        filename = f"downloaded_{uuid.uuid4().hex[:8]}.{self.settings.default_image_format}"
-        filepath = os.path.join(self.settings.temp_dir, filename)
+        filename = f"downloaded_{uuid.uuid4().hex[:8]}.{self.config.default_image_format}"
+        filepath = os.path.join(self.config.temp_dir, filename)
         
         urllib.request.urlretrieve(url, filepath)
         return filepath
@@ -1160,7 +1180,7 @@ class ContentInsertionTool(BaseTool):
         image_data = base64.b64decode(data)
         
         filename = f"base64_{uuid.uuid4().hex[:8]}.{format_info}"
-        filepath = os.path.join(self.settings.temp_dir, filename)
+        filepath = os.path.join(self.config.temp_dir, filename)
         
         with open(filepath, 'wb') as f:
             f.write(image_data)

aiecs/tools/docs/document_creator_tool.py

@@ -23,8 +23,7 @@ from typing import Dict, Any, List, Optional, Union
 from enum import Enum
 from pathlib import Path
 
-from pydantic import BaseModel, Field, ValidationError
-from pydantic_settings import BaseSettings
+from pydantic import BaseModel, Field, ValidationError, ConfigDict
 
 from aiecs.tools.base_tool import BaseTool
 from aiecs.tools import register_tool
@@ -82,18 +81,6 @@ class StylePreset(str, Enum):
     PROFESSIONAL = "professional"
 
 
-class DocumentCreatorSettings(BaseSettings):
-    """Configuration for DocumentCreatorTool"""
-    templates_dir: str = os.path.join(tempfile.gettempdir(), 'document_templates')
-    output_dir: str = os.path.join(tempfile.gettempdir(), 'created_documents')
-    default_format: DocumentFormat = DocumentFormat.MARKDOWN
-    default_style: StylePreset = StylePreset.DEFAULT
-    auto_backup: bool = True
-    include_metadata: bool = True
-    generate_toc: bool = True
-    
-    class Config:
-        env_prefix = "DOC_CREATOR_"
 
 
 class DocumentCreatorError(Exception):
@@ -129,15 +116,46 @@ class DocumentCreatorTool(BaseTool):
     - ContentInsertionTool for complex content
     """
     
+    # Configuration schema
+    class Config(BaseModel):
+        """Configuration for the document creator tool"""
+        model_config = ConfigDict(env_prefix="DOC_CREATOR_")
+        
+        templates_dir: str = Field(
+            default=os.path.join(tempfile.gettempdir(), 'document_templates'),
+            description="Directory for document templates"
+        )
+        output_dir: str = Field(
+            default=os.path.join(tempfile.gettempdir(), 'created_documents'),
+            description="Directory for created documents"
+        )
+        default_format: str = Field(
+            default="markdown",
+            description="Default output format"
+        )
+        default_style: str = Field(
+            default="default",
+            description="Default style preset"
+        )
+        auto_backup: bool = Field(
+            default=True,
+            description="Whether to automatically backup created documents"
+        )
+        include_metadata: bool = Field(
+            default=True,
+            description="Whether to include metadata in created documents"
+        )
+        generate_toc: bool = Field(
+            default=True,
+            description="Whether to generate table of contents automatically"
+        )
+    
     def __init__(self, config: Optional[Dict] = None):
         """Initialize Document Creator Tool with settings"""
         super().__init__(config)
-        self.settings = DocumentCreatorSettings()
-        if config:
-            try:
-                self.settings = self.settings.model_validate({**self.settings.model_dump(), **config})
-            except ValidationError as e:
-                raise ValueError(f"Invalid settings: {e}")
+        
+        # Parse configuration
+        self.config = self.Config(**(config or {}))
         
         self.logger = logging.getLogger(__name__)
         
@@ -152,8 +170,8 @@ class DocumentCreatorTool(BaseTool):
     
     def _init_directories(self):
         """Initialize required directories"""
-        os.makedirs(self.settings.templates_dir, exist_ok=True)
-        os.makedirs(self.settings.output_dir, exist_ok=True)
+        os.makedirs(self.config.templates_dir, exist_ok=True)
+        os.makedirs(self.config.output_dir, exist_ok=True)
     
     def _init_templates(self):
         """Initialize built-in templates"""
@@ -237,7 +255,7 @@ class DocumentCreatorTool(BaseTool):
             processed_metadata = self._process_metadata(metadata, output_format)
             
             # Step 4: Apply style preset
-            style_config = self._get_style_config(style_preset or self.settings.default_style)
+            style_config = self._get_style_config(style_preset or self.config.default_style)
             
             # Step 5: Create document from template
             document_content = self._create_document_from_template(
@@ -293,7 +311,7 @@ class DocumentCreatorTool(BaseTool):
         """
         try:
             # Load custom template
-            template_path = os.path.join(self.settings.templates_dir, template_name)
+            template_path = os.path.join(self.config.templates_dir, template_name)
             if not os.path.exists(template_path):
                 raise TemplateError(f"Template not found: {template_name}")
             
@@ -423,15 +441,15 @@ class DocumentCreatorTool(BaseTool):
         
         # Scan for custom templates
         custom_templates = []
-        if os.path.exists(self.settings.templates_dir):
-            for file in os.listdir(self.settings.templates_dir):
+        if os.path.exists(self.config.templates_dir):
+            for file in os.listdir(self.config.templates_dir):
                 if file.endswith(('.md', '.html', '.txt', '.json')):
                     custom_templates.append(file)
         
         return {
             "built_in_templates": [t.value for t in built_in_templates],
             "custom_templates": custom_templates,
-            "templates_directory": self.settings.templates_dir,
+            "templates_directory": self.config.templates_dir,
             "total_templates": len(built_in_templates) + len(custom_templates)
         }
     
@@ -952,7 +970,7 @@ class DocumentCreatorTool(BaseTool):
         """Generate output path for document"""
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
         filename = f"{document_type}_{timestamp}_{document_id[:8]}.{output_format.value}"
-        return os.path.join(self.settings.output_dir, filename)
+        return os.path.join(self.config.output_dir, filename)
     
     def _process_metadata(self, metadata: Dict[str, Any], output_format: DocumentFormat) -> Dict[str, Any]:
         """Process and validate metadata"""
@@ -996,7 +1014,7 @@ class DocumentCreatorTool(BaseTool):
                 content = content.replace(placeholder, str(value))
         
         # Add metadata header if required
-        if self.settings.include_metadata:
+        if self.config.include_metadata:
             metadata_header = self._generate_metadata_header(metadata, output_format)
             content = metadata_header + "\n\n" + content