praisonaiagents 0.0.59__py3-none-any.whl → 0.0.61__py3-none-any.whl

praisonaiagents/__init__.py

@@ -3,6 +3,7 @@ Praison AI Agents - A package for hierarchical AI agent task execution
 """
 
 from .agent.agent import Agent
+from .agent.image_agent import ImageAgent
 from .agents.agents import PraisonAIAgents
 from .task.task import Task
 from .tools.tools import Tools
@@ -30,6 +31,7 @@ Agents = PraisonAIAgents
 
 __all__ = [
     'Agent',
+    'ImageAgent',
     'PraisonAIAgents',
     'Agents',
     'Tools',

praisonaiagents/agent/__init__.py

@@ -1,4 +1,5 @@
 """Agent module for AI agents"""
 from .agent import Agent
+from .image_agent import ImageAgent
 
-__all__ = ['Agent'] 
+__all__ = ['Agent', 'ImageAgent']

praisonaiagents/agent/agent.py

@@ -16,7 +16,6 @@ from ..main import (
     display_self_reflection,
     ReflectionOutput,
     client,
-    error_logs,
     adisplay_instruction
 )
 import inspect

praisonaiagents/agent/image_agent.py

@@ -0,0 +1,213 @@
+"""
+ImageAgent - A specialized agent class for generating images using AI models.
+
+This class extends the base Agent class to provide specific functionality for image generation,
+including support for different image models, sizes, and quality settings.
+"""
+
+from typing import Optional, Any, Dict, Union, List
+from ..agent.agent import Agent
+from pydantic import BaseModel, Field
+import logging
+import warnings
+
+# Filter out Pydantic warning about fields
+warnings.filterwarnings("ignore", "Valid config keys have changed in V2", UserWarning)
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+class ImageGenerationConfig(BaseModel):
+    """Configuration for image generation settings."""
+    style: str = Field(default="natural", description="Style of the generated image")
+    response_format: str = Field(default="url", description="Format of the response (url or b64_json)")
+    timeout: int = Field(default=600, description="Timeout in seconds for the API call")
+    api_base: Optional[str] = Field(default=None, description="Optional API base URL")
+    api_key: Optional[str] = Field(default=None, description="Optional API key")
+    api_version: Optional[str] = Field(default=None, description="Optional API version (required for Azure dall-e-3)")
+
+class ImageAgent(Agent):
+    """
+    A specialized agent for generating images using AI models.
+    
+    This agent extends the base Agent class with specific functionality for image generation,
+    including support for different models, sizes, and quality settings.
+    """
+    
+    def __init__(
+        self,
+        name: Optional[str] = None,
+        role: Optional[str] = None,
+        goal: Optional[str] = None,
+        backstory: Optional[str] = None,
+        instructions: Optional[str] = None,
+        llm: Optional[Union[str, Any]] = None,
+        style: str = "natural",
+        response_format: str = "url",
+        timeout: int = 600,
+        api_base: Optional[str] = None,
+        api_key: Optional[str] = None,
+        api_version: Optional[str] = None,
+        verbose: Union[bool, int] = True,
+        **kwargs
+    ):
+        """Initialize ImageAgent with parameters."""
+        # Set default role and goal if not provided
+        role = role or "Image Generation Assistant"
+        goal = goal or "Generate high-quality images based on text descriptions"
+        backstory = backstory or "I am an AI assistant specialized in generating images from textual descriptions"
+
+        # Initialize the base agent
+        super().__init__(
+            name=name,
+            role=role,
+            goal=goal,
+            backstory=backstory,
+            instructions=instructions,
+            llm=llm,
+            verbose=verbose,
+            **kwargs
+        )
+
+        # Store image generation configuration
+        self.image_config = ImageGenerationConfig(
+            style=style,
+            response_format=response_format,
+            timeout=timeout,
+            api_base=api_base,
+            api_key=api_key,
+            api_version=api_version
+        )
+        
+        # Lazy load litellm
+        self._litellm = None
+
+        # Configure logging based on verbose level
+        self._configure_logging(verbose)
+
+    def _configure_logging(self, verbose: Union[bool, int]) -> None:
+        """Configure logging levels based on verbose setting."""
+        # Only suppress logs if not in debug mode
+        if not isinstance(verbose, bool) and verbose >= 10:
+            # Enable detailed debug logging
+            logging.getLogger("asyncio").setLevel(logging.DEBUG)
+            logging.getLogger("selector_events").setLevel(logging.DEBUG)
+            logging.getLogger("litellm.utils").setLevel(logging.DEBUG)
+            logging.getLogger("litellm.main").setLevel(logging.DEBUG)
+            if hasattr(self, 'litellm'):
+                self.litellm.suppress_debug_messages = False
+                self.litellm.set_verbose = True
+            # Don't filter warnings in debug mode
+            warnings.resetwarnings()
+        else:
+            # Suppress debug logging for normal operation
+            logging.getLogger("asyncio").setLevel(logging.WARNING)
+            logging.getLogger("selector_events").setLevel(logging.WARNING)
+            logging.getLogger("litellm.utils").setLevel(logging.WARNING)
+            logging.getLogger("litellm.main").setLevel(logging.WARNING)
+            logging.getLogger("httpx").setLevel(logging.WARNING)
+            logging.getLogger("httpcore").setLevel(logging.WARNING)
+            if hasattr(self, 'litellm'):
+                self.litellm.suppress_debug_messages = True
+                self.litellm._logging._disable_debugging()
+            # Suppress all warnings including Pydantic's
+            warnings.filterwarnings("ignore", category=RuntimeWarning)
+            warnings.filterwarnings("ignore", category=UserWarning)
+            warnings.filterwarnings("ignore", category=DeprecationWarning)
+
+    @property
+    def litellm(self):
+        """Lazy load litellm module when needed."""
+        if self._litellm is None:
+            try:
+                import litellm
+                from litellm import image_generation
+                
+                # Configure litellm to disable success handler logs
+                litellm.success_callback = []
+                litellm._logging._disable_debugging()
+                
+                self._litellm = image_generation
+                # Configure logging after litellm is loaded
+                self._configure_logging(self.verbose)
+            except ImportError:
+                raise ImportError(
+                    "litellm is required for image generation. "
+                    "Please install it with: pip install litellm"
+                )
+        return self._litellm
+
+    def generate_image(self, prompt: str, **kwargs) -> Dict[str, Any]:
+        """Generate an image based on the provided prompt."""
+        # Merge default config with any provided kwargs
+        config = self.image_config.dict(exclude_none=True)
+        config.update(kwargs)
+        
+        # Use llm parameter as the model
+        config['model'] = self.llm
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            transient=True
+        ) as progress:
+            try:
+                # Add a task for image generation
+                task = progress.add_task(f"[cyan]Generating image with {self.llm}...", total=None)
+                
+                # Use litellm's image generation
+                response = self.litellm(
+                    prompt=prompt,
+                    **config
+                )
+                
+                # Mark task as complete
+                progress.update(task, completed=True)
+                return response
+
+            except Exception as e:
+                error_msg = f"Error generating image: {str(e)}"
+                if self.verbose:
+                    self.console.print(f"[red]{error_msg}[/red]")
+                logging.error(error_msg)
+                raise
+
+    async def agenerate_image(self, prompt: str, **kwargs) -> Dict[str, Any]:
+        """Async wrapper for generate_image."""
+        return self.generate_image(prompt, **kwargs)
+
+    def chat(self, prompt: str, **kwargs) -> Dict[str, Any]:
+        """Generate an image from the prompt."""
+        try:
+            result = self.generate_image(prompt, **kwargs)
+            if self.verbose:
+                self.console.print(f"[green]Successfully generated image from prompt[/green]")
+            return result
+        except Exception as e:
+            error_msg = f"Failed to generate image: {str(e)}"
+            if self.verbose:
+                self.console.print(f"[red]{error_msg}[/red]")
+            return {"error": str(e)}
+
+    async def achat(
+        self,
+        prompt: str,
+        temperature: float = 0.2,
+        tools: Optional[List[Any]] = None,
+        output_json: Optional[str] = None,
+        output_pydantic: Optional[Any] = None,
+        reasoning_steps: bool = False,
+        **kwargs
+    ) -> Union[str, Dict[str, Any]]:
+        """Async chat method for image generation."""
+        try:
+            image_result = await self.agenerate_image(prompt, **kwargs)
+            if self.verbose:
+                self.console.print(f"[green]Successfully generated image from prompt[/green]")
+            return image_result
+        except Exception as e:
+            error_msg = f"Failed to generate image: {str(e)}"
+            if self.verbose:
+                self.console.print(f"[red]{error_msg}[/red]")
+            return {"error": str(e)}

praisonaiagents/agents/autoagents.py

@@ -8,10 +8,10 @@ It automatically handles agent creation, task setup, and execution flow.
 from .agents import PraisonAIAgents
 from ..agent.agent import Agent
 from ..task.task import Task
-from typing import List, Any, Optional, Dict, Union
+from typing import List, Any, Optional, Dict
 import logging
 import os
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 from ..main import display_instruction, display_tool_call, display_interaction, client
 
 # Define Pydantic models for structured output

praisonaiagents/llm/llm.py

@@ -1040,4 +1040,174 @@ Output MUST be JSON with 'reflection' and 'satisfactory'.
             if type(event) in event_types:
                 litellm._async_success_callback.remove(event)
                 
-        litellm.callbacks = events
+        litellm.callbacks = events
+
+    # Response without tool calls
+    def response(
+        self,
+        prompt: Union[str, List[Dict]],
+        system_prompt: Optional[str] = None,
+        temperature: float = 0.2,
+        stream: bool = True,
+        verbose: bool = True,
+        markdown: bool = True,
+        console: Optional[Console] = None,
+        **kwargs
+    ) -> str:
+        """Simple function to get model response without tool calls or complex features"""
+        try:
+            import litellm
+            import logging
+            logger = logging.getLogger(__name__)
+            
+            litellm.set_verbose = False
+            start_time = time.time()
+            
+            logger.debug("Using synchronous response function")
+            
+            # Build messages list
+            messages = []
+            if system_prompt:
+                messages.append({"role": "system", "content": system_prompt})
+            
+            # Add prompt to messages
+            if isinstance(prompt, list):
+                messages.append({"role": "user", "content": prompt})
+            else:
+                messages.append({"role": "user", "content": prompt})
+
+            # Get response from LiteLLM
+            if stream:
+                response_text = ""
+                if verbose:
+                    with Live(display_generating("", start_time), console=console or self.console, refresh_per_second=4) as live:
+                        for chunk in litellm.completion(
+                            model=self.model,
+                            messages=messages,
+                            temperature=temperature,
+                            stream=True,
+                            **kwargs
+                        ):
+                            if chunk and chunk.choices and chunk.choices[0].delta.content:
+                                content = chunk.choices[0].delta.content
+                                response_text += content
+                                live.update(display_generating(response_text, start_time))
+                else:
+                    for chunk in litellm.completion(
+                        model=self.model,
+                        messages=messages,
+                        temperature=temperature,
+                        stream=True,
+                        **kwargs
+                    ):
+                        if chunk and chunk.choices and chunk.choices[0].delta.content:
+                            response_text += chunk.choices[0].delta.content
+            else:
+                response = litellm.completion(
+                    model=self.model,
+                    messages=messages,
+                    temperature=temperature,
+                    stream=False,
+                    **kwargs
+                )
+                response_text = response.choices[0].message.content.strip()
+
+            if verbose:
+                display_interaction(
+                    prompt if isinstance(prompt, str) else prompt[0].get("text", ""),
+                    response_text,
+                    markdown=markdown,
+                    generation_time=time.time() - start_time,
+                    console=console or self.console
+                )
+            
+            return response_text.strip()
+
+        except Exception as error:
+            display_error(f"Error in response: {str(error)}")
+            raise
+
+    # Async version of response function. Response without tool calls
+    async def aresponse(
+        self,
+        prompt: Union[str, List[Dict]],
+        system_prompt: Optional[str] = None,
+        temperature: float = 0.2,
+        stream: bool = True,
+        verbose: bool = True,
+        markdown: bool = True,
+        console: Optional[Console] = None,
+        **kwargs
+    ) -> str:
+        """Async version of response function"""
+        try:
+            import litellm
+            import logging
+            logger = logging.getLogger(__name__)
+            
+            litellm.set_verbose = False
+            start_time = time.time()
+            
+            logger.debug("Using asynchronous response function")
+            
+            # Build messages list
+            messages = []
+            if system_prompt:
+                messages.append({"role": "system", "content": system_prompt})
+            
+            # Add prompt to messages
+            if isinstance(prompt, list):
+                messages.append({"role": "user", "content": prompt})
+            else:
+                messages.append({"role": "user", "content": prompt})
+
+            # Get response from LiteLLM
+            if stream:
+                response_text = ""
+                if verbose:
+                    with Live(display_generating("", start_time), console=console or self.console, refresh_per_second=4) as live:
+                        async for chunk in await litellm.acompletion(
+                            model=self.model,
+                            messages=messages,
+                            temperature=temperature,
+                            stream=True,
+                            **kwargs
+                        ):
+                            if chunk and chunk.choices and chunk.choices[0].delta.content:
+                                content = chunk.choices[0].delta.content
+                                response_text += content
+                                live.update(display_generating(response_text, start_time))
+                else:
+                    async for chunk in await litellm.acompletion(
+                        model=self.model,
+                        messages=messages,
+                        temperature=temperature,
+                        stream=True,
+                        **kwargs
+                    ):
+                        if chunk and chunk.choices and chunk.choices[0].delta.content:
+                            response_text += chunk.choices[0].delta.content
+            else:
+                response = await litellm.acompletion(
+                    model=self.model,
+                    messages=messages,
+                    temperature=temperature,
+                    stream=False,
+                    **kwargs
+                )
+                response_text = response.choices[0].message.content.strip()
+
+            if verbose:
+                display_interaction(
+                    prompt if isinstance(prompt, str) else prompt[0].get("text", ""),
+                    response_text,
+                    markdown=markdown,
+                    generation_time=time.time() - start_time,
+                    console=console or self.console
+                )
+            
+            return response_text.strip()
+
+        except Exception as error:
+            display_error(f"Error in response_async: {str(error)}")
+            raise

praisonaiagents/tools/train/data/generatecot.py

@@ -1,8 +1,16 @@
 from typing import Dict, Optional, Union, Any
 import json
 from datetime import datetime
-from openai import OpenAI
-from pydantic import BaseModel
+import os
+import logging
+
+# Setup logging based on environment variable
+log_level = os.getenv('LOGLEVEL', 'INFO').upper()
+logging.basicConfig(
+    level=log_level,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
 
 # Lazy loader for LLM
 def get_llm():
@@ -21,16 +29,24 @@ class GenerateCOT:
         qa_pairs: Optional[Dict[str, str]] = None,
         model: str = "gpt-4o-mini",
         api_key: Optional[str] = None,
-        max_attempts: int = 3
+        max_attempts: int = 3,
+        verbose: bool = True,
+        temperature: float = 0.5
     ):
         self.qa_pairs = qa_pairs or {}
         self.max_attempts = max_attempts
         self.solutions = {}
         self.llm = get_llm()(model=model)  # Get LLM class and instantiate
         self.model = model
-
+        self.temperature = temperature
+        self.verbose = verbose
+        logger.debug(f"Initialized GenerateCOT with model={model}, max_attempts={max_attempts}")
+        
     def _ask_ai(self, prompt: str) -> str:
-        return self.llm.get_response(prompt, temperature=0.7)
+        logger.debug(f"Sending prompt to LLM: {prompt[:100]}...")
+        response = self.llm.response(prompt, temperature=self.temperature)
+        logger.debug(f"Received response: {response[:100]}...")
+        return response
         
     def _build_solution_prompt(self, question: str, context: str) -> str:
         return f"""
@@ -106,7 +122,7 @@ class GenerateCOT:
         try:
             score = float(self._ask_ai(prompt))
             return min(max(score, 0), 1)
-        except:
+        except ValueError:
             return 0.0
             
     def cot_run(self, question: str) -> str:
@@ -245,23 +261,33 @@ class GenerateCOT:
 
     def cot_run_dict(self, question: str) -> dict:
         """Uses the dictionary-based solution approach, storing the final solution in self.solutions."""
+        logger.debug(f"Starting cot_run_dict for question: {question}")
+        
         solution = self.cot_generate_dict(question)
+        logger.debug(f"Initial solution generated: {str(solution)[:100]}...")
+        
         if self.cot_check(question, solution["final_answer"]):
+            logger.debug("Initial solution passed verification")
             self.solutions[question] = solution
             return solution
 
+        logger.debug("Initial solution failed verification, attempting improvement")
         improved = self.cot_improve_dict(question, solution["thought_process"])
         if self.cot_check(question, improved["final_answer"]):
+            logger.debug("Improved solution passed verification")
             self.solutions[question] = improved
             return improved
 
+        logger.debug("Checking for errors in improved solution")
         error_pos = self.cot_find_error(question, improved["thought_process"])
         if error_pos != -1:
+            logger.debug(f"Found error at position {error_pos}, generating final solution")
             partial_solution = '. '.join(improved["thought_process"].split('. ')[:error_pos]) + '.'
             final = self.cot_generate_dict(question, partial_solution)
             self.solutions[question] = final
             return final
 
+        logger.debug("Using improved solution as final result")
         self.solutions[question] = improved
         return improved
 
@@ -308,6 +334,7 @@ class GenerateCOT:
     ) -> Optional[str]:
         """Export solutions in CSV format."""
         try:
+            import csv
             self._is_qa_pairs(qa_pairs)  # Validate format
             if qa_pairs:
                 self.qa_pairs.update(qa_pairs)
@@ -332,29 +359,30 @@ class GenerateCOT:
         answer: str,
         filepath: str = 'dataset.csv'
     ) -> Optional[str]:
-        """
-        Save a single question-answer pair with chain of thought to CSV file.
-        Creates file with headers if it doesn't exist.
-        """
+        """Save a single question-answer pair with chain of thought to CSV file."""
+        logger.debug(f"Saving QA pair to {filepath}")
         try:
-            # Add the current QA pair to self.qa_pairs
             self.qa_pairs[question] = answer
+            logger.debug("Added QA pair to internal dictionary")
             
-            # Generate solution
             solution = self.cot_run_dict(question)
+            logger.debug("Generated solution for question")
             
             import csv
             import os
             file_exists = os.path.exists(filepath)
+            logger.debug(f"File exists: {file_exists}")
 
             with open(filepath, 'a', newline='', encoding='utf-8') as f:
                 writer = csv.writer(f)
                 if not file_exists:
+                    logger.debug("Creating new file with headers")
                     writer.writerow(['instruction', 'input', 'output'])
                 writer.writerow([question, '', solution.get("thought_process", "")])
+                logger.debug("Wrote solution to file")
             return filepath
         except Exception as e:
-            print(f"Error appending to CSV: {e}")
+            logger.error(f"Error saving to CSV: {str(e)}")
             return None
 
     # Rename existing function to indicate it handles qa_pairs dictionary
@@ -393,33 +421,36 @@ class GenerateCOT:
         private: bool = False
     ) -> str:
         """Upload generated solutions to HuggingFace datasets."""
+        logger.debug(f"Attempting to upload {filepath} to HuggingFace as {dataset_name}")
         try:
             from datasets import Dataset
-            from huggingface_hub import HfApi, login
             import pandas as pd
             
-            # Determine file type and load data
+            logger.debug(f"Loading data from {filepath}")
             if filepath.endswith('.csv'):
                 data = pd.read_csv(filepath)
+                logger.debug(f"Loaded CSV with {len(data)} rows")
             elif filepath.endswith('.json'):
                 data = pd.read_json(filepath)
+                logger.debug(f"Loaded JSON with {len(data)} records")
             else:
                 raise ValueError("Only CSV and JSON files are supported")
                 
-            # Convert to HuggingFace dataset
+            logger.debug("Converting to HuggingFace dataset")
             dataset = Dataset.from_pandas(data)
             
-            # Upload to HuggingFace
             repo_id = f"{huggingface_username}/{dataset_name}"
+            logger.debug(f"Pushing to hub: {repo_id}")
             dataset.push_to_hub(
                 repo_id,
                 private=private
             )
             
+            logger.debug("Upload completed successfully")
             return f"Dataset uploaded successfully to {repo_id}"
             
         except Exception as e:
-            print(f"Error uploading to HuggingFace: {e}")
+            logger.error(f"Error uploading to HuggingFace: {str(e)}")
             return None
 
 # Usage example:

{praisonaiagents-0.0.59.dist-info → praisonaiagents-0.0.61.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: praisonaiagents
-Version: 0.0.59
+Version: 0.0.61
 Summary: Praison AI agents for completing complex tasks with Self Reflection Agents
 Author: Mervin Praison
 Requires-Dist: pydantic

{praisonaiagents-0.0.59.dist-info → praisonaiagents-0.0.61.dist-info}/RECORD

@@ -1,15 +1,16 @@
-praisonaiagents/__init__.py,sha256=JtPibbmeFv3meIb3vkKjckB0p7m-Vqt2RYPwOH8P41k,1228
+praisonaiagents/__init__.py,sha256=frdIvimDY-kU9j-9yXV1z4NtXypfPvyvlnac5mgBCuQ,1288
 praisonaiagents/main.py,sha256=0kB9gn9meXtr4EIrdgA2lAioKIHCRJ61audsGDwuTm4,14428
-praisonaiagents/agent/__init__.py,sha256=sKO8wGEXvtCrvV1e834r1Okv0XAqAxqZCqz6hKLiTvA,79
-praisonaiagents/agent/agent.py,sha256=VZPci7g_LAvTz7_rWvWAZ1JgCGKQc1vSfI6x0fqi2os,57598
+praisonaiagents/agent/__init__.py,sha256=j0T19TVNbfZcClvpbZDDinQxZ0oORgsMrMqx16jZ-bA,128
+praisonaiagents/agent/agent.py,sha256=_v8WrWK1oP4OpPgp30nH4xbPyREnjOnRT1cyHUa2T9Q,57582
+praisonaiagents/agent/image_agent.py,sha256=-5MXG594HVwSpFMcidt16YBp7udtik-Cp7eXlzLE1fY,8696
 praisonaiagents/agents/__init__.py,sha256=_1d6Pqyk9EoBSo7E68sKyd1jDRlN1vxvVIRpoMc0Jcw,168
 praisonaiagents/agents/agents.py,sha256=94YPQl-hl-EPY6-Xk2Rj9wlIs9YtiLQbsutSOXWX8QI,36156
-praisonaiagents/agents/autoagents.py,sha256=bjC2O5oZmoJItJXIMPTWc2lsp_AJC9tMiTQOal2hwPA,13532
+praisonaiagents/agents/autoagents.py,sha256=olYDn--rlJp-SckxILqmREkkgNlzCgEEcAUzfMj-54E,13518
 praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9bge0Ujuto,246
 praisonaiagents/knowledge/chunking.py,sha256=FzoNY0q8MkvG4gADqk4JcRhmH3lcEHbRdonDgitQa30,6624
 praisonaiagents/knowledge/knowledge.py,sha256=fQNREDiwdoisfIxJBLVkteXgq_8Gbypfc3UaZbxf5QY,13210
 praisonaiagents/llm/__init__.py,sha256=ttPQQJQq6Tah-0updoEXDZFKWtJAM93rBWRoIgxRWO8,689
-praisonaiagents/llm/llm.py,sha256=G2wKMwitWBJRS6nOq9W77zXtsxvJwsVwXFOKYcllY0E,51386
+praisonaiagents/llm/llm.py,sha256=SYfiMOmduEOhwraewmXSydu6tNBb9n5uKRxnO9moGYM,58151
 praisonaiagents/memory/memory.py,sha256=I8dOTkrl1i-GgQbDcrFOsSruzJ7MiI6Ys37DK27wrUs,35537
 praisonaiagents/process/__init__.py,sha256=lkYbL7Hn5a0ldvJtkdH23vfIIZLIcanK-65C0MwaorY,52
 praisonaiagents/process/process.py,sha256=HPw84OhnKQW3EyrDkpoQu0DcpxThbrzR2hWUgwQh9Pw,59955
@@ -35,8 +36,8 @@ praisonaiagents/tools/wikipedia_tools.py,sha256=pGko-f33wqXgxJTv8db7TbizY5XnzBQR
 praisonaiagents/tools/xml_tools.py,sha256=iYTMBEk5l3L3ryQ1fkUnNVYK-Nnua2Kx2S0dxNMMs1A,17122
 praisonaiagents/tools/yaml_tools.py,sha256=uogAZrhXV9O7xvspAtcTfpKSQYL2nlOTvCQXN94-G9A,14215
 praisonaiagents/tools/yfinance_tools.py,sha256=s2PBj_1v7oQnOobo2fDbQBACEHl61ftG4beG6Z979ZE,8529
-praisonaiagents/tools/train/data/generatecot.py,sha256=k1gZHtgY1poVp5kajhgs4S9a4-epdA8NyZfYTa34lQU,17651
-praisonaiagents-0.0.59.dist-info/METADATA,sha256=w6DYqKW5P9b2Rqu02j5Lt4-6K7f-InDrtUfV7fYu_FM,830
-praisonaiagents-0.0.59.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-praisonaiagents-0.0.59.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.59.dist-info/RECORD,,
+praisonaiagents/tools/train/data/generatecot.py,sha256=H6bNh-E2hqL5MW6kX3hqZ05g9ETKN2-kudSjiuU_SD8,19403
+praisonaiagents-0.0.61.dist-info/METADATA,sha256=I_883Gdgeer-wm8RVmBk-kAdkHQloL0ewZ96wqwW26c,830
+praisonaiagents-0.0.61.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+praisonaiagents-0.0.61.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.61.dist-info/RECORD,,