praisonaiagents 0.0.54__py3-none-any.whl → 0.0.57__py3-none-any.whl

praisonaiagents/agent/agent.py

@@ -97,36 +97,79 @@ def process_stream_chunks(chunks):
         
         content_list = []
         reasoning_list = []
+        tool_calls = []
+        current_tool_call = None
 
+        # First pass: Get initial tool call data
         for chunk in chunks:
             if not hasattr(chunk, "choices") or not chunk.choices:
                 continue
             
-            # Track usage from each chunk
-            if hasattr(chunk, "usage"):
-                completion_tokens += getattr(chunk.usage, "completion_tokens", 0)
-                prompt_tokens += getattr(chunk.usage, "prompt_tokens", 0)
-                
             delta = getattr(chunk.choices[0], "delta", None)
             if not delta:
                 continue
-                
+
+            # Handle content and reasoning
             if hasattr(delta, "content") and delta.content:
                 content_list.append(delta.content)
             if hasattr(delta, "reasoning_content") and delta.reasoning_content:
                 reasoning_list.append(delta.reasoning_content)
+            
+            # Handle tool calls
+            if hasattr(delta, "tool_calls") and delta.tool_calls:
+                for tool_call_delta in delta.tool_calls:
+                    if tool_call_delta.index is not None and tool_call_delta.id:
+                        # Found the initial tool call
+                        current_tool_call = {
+                            "id": tool_call_delta.id,
+                            "type": "function",
+                            "function": {
+                                "name": tool_call_delta.function.name,
+                                "arguments": ""
+                            }
+                        }
+                        while len(tool_calls) <= tool_call_delta.index:
+                            tool_calls.append(None)
+                        tool_calls[tool_call_delta.index] = current_tool_call
+                        current_tool_call = tool_calls[tool_call_delta.index]
+                    elif current_tool_call is not None and hasattr(tool_call_delta.function, "arguments"):
+                        if tool_call_delta.function.arguments:
+                            current_tool_call["function"]["arguments"] += tool_call_delta.function.arguments
+
+        # Remove any None values and empty tool calls
+        tool_calls = [tc for tc in tool_calls if tc and tc["id"] and tc["function"]["name"]]
 
         combined_content = "".join(content_list) if content_list else ""
         combined_reasoning = "".join(reasoning_list) if reasoning_list else None
         finish_reason = getattr(last_chunk.choices[0], "finish_reason", None) if hasattr(last_chunk, "choices") and last_chunk.choices else None
 
+        # Create ToolCall objects
+        processed_tool_calls = []
+        if tool_calls:
+            try:
+                from openai.types.chat import ChatCompletionMessageToolCall
+                for tc in tool_calls:
+                    tool_call = ChatCompletionMessageToolCall(
+                        id=tc["id"],
+                        type=tc["type"],
+                        function={
+                            "name": tc["function"]["name"],
+                            "arguments": tc["function"]["arguments"]
+                        }
+                    )
+                    processed_tool_calls.append(tool_call)
+            except Exception as e:
+                print(f"Error processing tool call: {e}")
+
         message = ChatCompletionMessage(
             content=combined_content,
-            reasoning_content=combined_reasoning
+            role="assistant",
+            reasoning_content=combined_reasoning,
+            tool_calls=processed_tool_calls if processed_tool_calls else None
         )
         
         choice = Choice(
-            finish_reason=finish_reason,
+            finish_reason=finish_reason or "tool_calls" if processed_tool_calls else None,
             index=0,
             message=message
         )
@@ -528,6 +571,53 @@ Your Goal: {self.goal}
     def __str__(self):
         return f"Agent(name='{self.name}', role='{self.role}', goal='{self.goal}')"
 
+    def _process_stream_response(self, messages, temperature, start_time, formatted_tools=None, reasoning_steps=False):
+        """Process streaming response and return final response"""
+        try:
+            # Create the response stream
+            response_stream = client.chat.completions.create(
+                model=self.llm,
+                messages=messages,
+                temperature=temperature,
+                tools=formatted_tools if formatted_tools else None,
+                stream=True
+            )
+            
+            full_response_text = ""
+            reasoning_content = ""
+            chunks = []
+            
+            # Create Live display with proper configuration
+            with Live(
+                display_generating("", start_time),
+                console=self.console,
+                refresh_per_second=4,
+                transient=True,
+                vertical_overflow="ellipsis",
+                auto_refresh=True
+            ) as live:
+                for chunk in response_stream:
+                    chunks.append(chunk)
+                    if chunk.choices[0].delta.content:
+                        full_response_text += chunk.choices[0].delta.content
+                        live.update(display_generating(full_response_text, start_time))
+                    
+                    # Update live display with reasoning content if enabled
+                    if reasoning_steps and hasattr(chunk.choices[0].delta, "reasoning_content"):
+                        rc = chunk.choices[0].delta.reasoning_content
+                        if rc:
+                            reasoning_content += rc
+                            live.update(display_generating(f"{full_response_text}\n[Reasoning: {reasoning_content}]", start_time))
+            
+            # Clear the last generating display with a blank line
+            self.console.print()
+            final_response = process_stream_chunks(chunks)
+            return final_response
+            
+        except Exception as e:
+            display_error(f"Error in stream processing: {e}")
+            return None
+
     def _chat_completion(self, messages, temperature=0.2, tools=None, stream=True, reasoning_steps=False):
         start_time = time.time()
         logging.debug(f"{self.name} sending messages to LLM: {messages}")
@@ -554,20 +644,31 @@ Your Goal: {self.goal}
                     logging.warning(f"Tool {tool} not recognized")
 
         try:
-            initial_response = client.chat.completions.create(
-                model=self.llm,
-                messages=messages,
-                temperature=temperature,
-                tools=formatted_tools if formatted_tools else None,
-                stream=False
-            )
+            if stream:
+                # Process as streaming response with formatted tools
+                final_response = self._process_stream_response(
+                    messages, 
+                    temperature, 
+                    start_time, 
+                    formatted_tools=formatted_tools if formatted_tools else None,
+                    reasoning_steps=reasoning_steps
+                )
+            else:
+                # Process as regular non-streaming response
+                final_response = client.chat.completions.create(
+                    model=self.llm,
+                    messages=messages,
+                    temperature=temperature,
+                    tools=formatted_tools if formatted_tools else None,
+                    stream=False
+                )
 
-            tool_calls = getattr(initial_response.choices[0].message, 'tool_calls', None)
+            tool_calls = getattr(final_response.choices[0].message, 'tool_calls', None)
 
             if tool_calls:
                 messages.append({
-                    "role": "assistant",
-                    "content": initial_response.choices[0].message.content,
+                    "role": "assistant", 
+                    "content": final_response.choices[0].message.content,
                     "tool_calls": tool_calls
                 })
 
@@ -590,55 +691,24 @@ Your Goal: {self.goal}
                         "content": results_str
                     })
 
-            if stream:
-                response_stream = client.chat.completions.create(
-                    model=self.llm,
-                    messages=messages,
-                    temperature=temperature,
-                    stream=True
-                )
-                full_response_text = ""
-                reasoning_content = ""
-                chunks = []
-                
-                # Create Live display with proper configuration
-                with Live(
-                    display_generating("", start_time),
-                    console=self.console,
-                    refresh_per_second=4,
-                    transient=True,
-                    vertical_overflow="ellipsis",
-                    auto_refresh=True
-                ) as live:
-                    for chunk in response_stream:
-                        chunks.append(chunk)
-                        if chunk.choices[0].delta.content:
-                            full_response_text += chunk.choices[0].delta.content
-                            live.update(display_generating(full_response_text, start_time))
-                        
-                        # Update live display with reasoning content if enabled
-                        if reasoning_steps and hasattr(chunk.choices[0].delta, "reasoning_content"):
-                            rc = chunk.choices[0].delta.reasoning_content
-                            if rc:
-                                reasoning_content += rc
-                                live.update(display_generating(f"{full_response_text}\n[Reasoning: {reasoning_content}]", start_time))
-                
-                # Clear the last generating display with a blank line
-                self.console.print()
-                
-                final_response = process_stream_chunks(chunks)
-                return final_response
-            else:
-                if tool_calls:
+                # Get final response after tool calls
+                if stream:
+                    final_response = self._process_stream_response(
+                        messages, 
+                        temperature, 
+                        start_time,
+                        formatted_tools=formatted_tools if formatted_tools else None,
+                        reasoning_steps=reasoning_steps
+                    )
+                else:
                     final_response = client.chat.completions.create(
                         model=self.llm,
                         messages=messages,
                         temperature=temperature,
                         stream=False
                     )
-                    return final_response
-                else:
-                    return initial_response
+
+            return final_response
 
         except Exception as e:
             display_error(f"Error in chat completion: {e}")
@@ -758,8 +828,7 @@ Your Goal: {self.goal}
 
                     tool_calls = getattr(response.choices[0].message, 'tool_calls', None)
                     response_text = response.choices[0].message.content.strip()
-
-                    if tool_calls:
+                    if tool_calls: ## TODO: Most likely this tool call is already called in _chat_completion, so maybe we can remove this.
                         messages.append({
                             "role": "assistant",
                             "content": response_text,

praisonaiagents/llm/llm.py

@@ -17,6 +17,8 @@ from ..main import (
 from rich.console import Console
 from rich.live import Live
 
+# TODO: Include in-build tool calling in LLM class
+# TODO: Restructure so that duplicate calls are not made (Sync with agent.py)
 class LLMContextLengthExceededException(Exception):
     """Raised when LLM context length is exceeded"""
     def __init__(self, message: str):
@@ -111,11 +113,28 @@ class LLM:
             litellm.success_callback = []
             litellm._async_success_callback = []
             litellm.callbacks = []
-            # Additional logging suppression
-            litellm.suppress_debug_messages = True
-            litellm._logging._disable_debugging()
-            logging.getLogger("litellm.utils").setLevel(logging.WARNING)
-            logging.getLogger("litellm.main").setLevel(logging.WARNING)
+            
+            verbose = extra_settings.get('verbose', True)
+            
+            # 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)
+                litellm.suppress_debug_messages = False
+                litellm.set_verbose = True
+            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)
+                litellm.suppress_debug_messages = True
+                litellm._logging._disable_debugging()
+                warnings.filterwarnings("ignore", category=RuntimeWarning)
+            
         except ImportError:
             raise ImportError(
                 "LiteLLM is required but not installed. "
@@ -143,7 +162,7 @@ class LLM:
         self.extra_settings = extra_settings
         self.console = Console()
         self.chat_history = []
-        self.verbose = extra_settings.get('verbose', True)
+        self.verbose = verbose
         self.markdown = extra_settings.get('markdown', True)
         self.self_reflect = extra_settings.get('self_reflect', False)
         self.max_reflect = extra_settings.get('max_reflect', 3)

praisonaiagents/process/process.py

@@ -44,6 +44,8 @@ class Process:
         current_task = start_task
         visited_tasks = set()
         loop_data = {}  # Store loop-specific data
+
+        # TODO: start task with loop feature is not available in aworkflow method
         
         while current_task:
             current_iter += 1
@@ -350,9 +352,10 @@ Provide a JSON with the structure:
                             if row:  # Skip empty rows
                                 task_desc = row[0]  # Take first column
                                 row_task = Task(
-                                    description=task_desc,  # Keep full row as description
+                                    description=f"{start_task.description}\n{task_desc}" if start_task.description else task_desc,
                                     agent=start_task.agent,
-                                    name=task_desc,       # Use first column as name
+                                    name=f"{start_task.name}_{i+1}" if start_task.name else task_desc,
+                                    expected_output=getattr(start_task, 'expected_output', None),
                                     is_start=(i == 0),
                                     task_type="task",
                                     condition={
@@ -374,9 +377,10 @@ Provide a JSON with the structure:
                         previous_task = None
                         for i, line in enumerate(lines):
                             row_task = Task(
-                                description=line.strip(),
+                                description=f"{start_task.description}\n{line.strip()}" if start_task.description else line.strip(),
                                 agent=start_task.agent,
-                                name=line.strip(),
+                                name=f"{start_task.name}_{i+1}" if start_task.name else line.strip(),
+                                expected_output=getattr(start_task, 'expected_output', None),
                                 is_start=(i == 0),
                                 task_type="task",
                                 condition={

praisonaiagents/tools/__init__.py

@@ -135,6 +135,27 @@ TOOL_MAPPINGS = {
     'group_by': ('.pandas_tools', 'PandasTools'),
     'pivot_table': ('.pandas_tools', 'PandasTools'),
     'pandas_tools': ('.pandas_tools', 'PandasTools'),
+
+    # Chain of Thought Training Tools
+    'cot_run': ('.train.data.generatecot', 'GenerateCOT'),           # Orchestrates text solution
+    'cot_run_dict': ('.train.data.generatecot', 'GenerateCOT'),      # Orchestrates dict-based solution
+    'cot_generate': ('.train.data.generatecot', 'GenerateCOT'),      # Generate text solution
+    'cot_generate_dict': ('.train.data.generatecot', 'GenerateCOT'), # Generate structured solution
+    'cot_improve': ('.train.data.generatecot', 'GenerateCOT'),       # Improve text solution
+    'cot_improve_dict': ('.train.data.generatecot', 'GenerateCOT'),  # Improve dict-based solution
+    'cot_check': ('.train.data.generatecot', 'GenerateCOT'),         # Check correctness
+    'cot_find_error': ('.train.data.generatecot', 'GenerateCOT'),    # Locate error in solution
+    'cot_load_answers': ('.train.data.generatecot', 'GenerateCOT'),  # Load QA pairs
+    
+    # COT Save/Export with QA Pairs
+    'cot_save_solutions_with_qa_pairs': ('.train.data.generatecot', 'GenerateCOT'),    # Save with QA pairs
+    'cot_append_solutions_with_qa_pairs': ('.train.data.generatecot', 'GenerateCOT'),  # Append with QA pairs
+    'cot_export_json_with_qa_pairs': ('.train.data.generatecot', 'GenerateCOT'),       # Export JSON with QA pairs
+    'cot_export_csv_with_qa_pairs': ('.train.data.generatecot', 'GenerateCOT'),        # Export CSV with QA pairs
+    'cot_append_csv_with_qa_pairs': ('.train.data.generatecot', 'GenerateCOT'),        # Append CSV with QA pairs
+    'cot_save': ('.train.data.generatecot', 'GenerateCOT'),                           # Save single QA to file
+    'cot_upload_to_huggingface': ('.train.data.generatecot', 'GenerateCOT'),           # Upload dataset to HuggingFace
+    'cot_tools': ('.train.data.generatecot', 'GenerateCOT'),                           # Full toolkit access
 }
 
 _instances = {}  # Cache for class instances
@@ -161,7 +182,7 @@ def __getattr__(name: str) -> Any:
         ]:
             return getattr(module, name)
         if name in ['file_tools', 'pandas_tools', 'wikipedia_tools',
-                   'newspaper_tools', 'arxiv_tools', 'spider_tools', 'duckdb_tools', 'csv_tools', 'json_tools', 'excel_tools', 'xml_tools', 'yaml_tools', 'calculator_tools', 'python_tools', 'shell_tools']:
+                   'newspaper_tools', 'arxiv_tools', 'spider_tools', 'duckdb_tools', 'csv_tools', 'json_tools', 'excel_tools', 'xml_tools', 'yaml_tools', 'calculator_tools', 'python_tools', 'shell_tools', 'cot_tools']:
             return module  # Returns the callable module
         return getattr(module, name)
     else:

praisonaiagents/tools/train/data/generatecot.py

@@ -0,0 +1,493 @@
+from typing import Dict, Optional, Union, Any
+import json
+from datetime import datetime
+from openai import OpenAI
+from pydantic import BaseModel
+
+# Lazy loader for LLM
+def get_llm():
+    try:
+        from praisonaiagents.llm.llm import LLM
+        return LLM
+    except ImportError:
+        raise ImportError(
+            "LLM is required for this toolbut not installed. "
+            "Please install with: pip install 'praisonaiagents[llm]' datasets huggingface-hub pandas"
+        )
+
+class GenerateCOT:
+    def __init__(
+        self,
+        qa_pairs: Optional[Dict[str, str]] = None,
+        model: str = "gpt-4o-mini",
+        api_key: Optional[str] = None,
+        max_attempts: int = 100
+    ):
+        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
+
+    def _ask_ai(self, prompt: str) -> str:
+        return self.llm.get_response(prompt, temperature=0.7)
+        
+    def _build_solution_prompt(self, question: str, context: str) -> str:
+        return f"""
+        Solve this problem step by step: {question}
+        Context: {context}
+        Steps needed:
+        1. Break down the problem
+        2. Show your work
+        3. Explain each step
+        4. Give final answer
+        """
+
+    def cot_generate(self, question: str, context: str = "") -> str:
+        prompt = self._build_solution_prompt(question, context)
+        return self._ask_ai(prompt)
+        
+    def cot_check(self, question: str, answer: str) -> bool:
+        if question not in self.qa_pairs:
+            raise ValueError(f"No correct answer found for: {question}")
+            
+        prompt = f"""
+        Question: {question}
+        Given Answer: {answer}
+        Correct Answer: {self.qa_pairs[question]}
+        Is the given answer correct? Reply only with 'true' or 'false'.
+        """
+        return self._ask_ai(prompt).lower().strip() == "true"
+        
+    def cot_find_error(self, question: str, solution: str) -> int:
+        if self.cot_check(question, solution):
+            return -1
+            
+        sentences = [s.strip() for s in solution.replace('。', '.').split('.') if s.strip()]
+        left, right = 0, len(sentences)
+        
+        while left < right:
+            mid = (left + right) // 2
+            partial = '. '.join(sentences[:mid]) + '.'
+            if self.cot_check(question, partial):
+                left = mid + 1
+            else:
+                right = mid
+                
+        return left
+        
+    def cot_improve(self, question: str, current: str) -> str:
+        best_solution = current
+        best_score = self._rate_solution(question, current)
+        
+        for _ in range(self.max_attempts):
+            new_solution = self.cot_generate(question, current)
+            new_score = self._rate_solution(question, new_solution)
+            
+            if new_score > best_score:
+                best_solution = new_solution
+                best_score = new_score
+                
+            if best_score > 0.9:
+                break
+                
+        return best_solution
+        
+    def _rate_solution(self, question: str, solution: str) -> float:
+        prompt = f"""
+        Rate this solution from 0 to 1:
+        Question: {question}
+        Solution: {solution}
+        Correct Answer: {self.qa_pairs.get(question, '')}
+        Return only a number between 0 and 1.
+        """
+        try:
+            score = float(self._ask_ai(prompt))
+            return min(max(score, 0), 1)
+        except:
+            return 0.0
+            
+    def cot_run(self, question: str) -> str:
+        """Run COT generation for a single question."""
+        solution = self.cot_generate(question)
+        if self.cot_check(question, solution):
+            return solution
+
+        solution = self.cot_improve(question, solution)
+        
+        error_pos = self.cot_find_error(question, solution)
+        if error_pos != -1:
+            correct_part = '. '.join(solution.split('. ')[:error_pos]) + '.'
+            solution = self.cot_generate(question, correct_part)
+
+        self.solutions[question] = {
+            "solution": solution,
+            "error_position": error_pos,
+        }
+        return solution
+        
+    def cot_load_answers(self, filepath: str) -> bool:
+        try:
+            with open(filepath, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            self.qa_pairs.update(data)
+            return True
+        except Exception as e:
+            print(f"Error loading answers: {e}")
+            return False
+            
+    def _is_qa_pairs(self, qa_pairs: Any) -> bool:
+        """Validate if input is a proper QA pairs dictionary."""
+        if not qa_pairs:
+            return True  # None or empty is valid
+        if not isinstance(qa_pairs, dict):
+            raise ValueError("qa_pairs must be a dictionary with questions as keys and answers as values")
+        return True
+
+    def cot_append_solutions_with_qa_pairs(
+        self,
+        filepath: str = 'solutions.json',
+        qa_pairs: Optional[Dict[str, str]] = None
+    ) -> None:
+        """Appends current solutions to existing file or creates a new one."""
+        try:
+            self._is_qa_pairs(qa_pairs)  # Validate format
+            if qa_pairs:
+                self.qa_pairs.update(qa_pairs)
+
+            data = {
+                "solutions": self.solutions,
+                "qa_pairs": self.qa_pairs,
+                "saved_at": datetime.now().isoformat()
+            }
+
+            existing_data = {}
+            try:
+                with open(filepath, 'r', encoding='utf-8') as f:
+                    existing_data = json.load(f)
+            except (FileNotFoundError, json.JSONDecodeError):
+                pass
+
+            if existing_data:
+                existing_data["solutions"].update(data["solutions"])
+                existing_data["qa_pairs"].update(data["qa_pairs"])
+                existing_data["saved_at"] = data["saved_at"]
+                data = existing_data
+
+            with open(filepath, 'w', encoding='utf-8') as f:
+                json.dump(data, f, ensure_ascii=False, indent=2)
+        except Exception as e:
+            print(f"Error appending solutions: {e}")
+
+    def cot_save_solutions_with_qa_pairs(
+        self,
+        filepath: str = 'solutions.json',
+        append: bool = False,
+        qa_pairs: Optional[Dict[str, str]] = None
+    ) -> None:
+        try:
+            self._is_qa_pairs(qa_pairs)  # Validate format
+            if qa_pairs:
+                self.qa_pairs.update(qa_pairs)
+
+            if append:
+                self.cot_append_solutions_with_qa_pairs(filepath)
+                return
+
+            data = {
+                "solutions": self.solutions,
+                "qa_pairs": self.qa_pairs,
+                "saved_at": datetime.now().isoformat()
+            }
+            with open(filepath, 'w', encoding='utf-8') as f:
+                json.dump(data, f, ensure_ascii=False, indent=2)
+        except Exception as e:
+            print(f"Error saving solutions: {e}")
+
+    def cot_generate_dict(self, question: str, context: str = "") -> dict:
+        prompt = self._build_solution_prompt(question, context)
+        thought_process = self._ask_ai(prompt)
+        
+        final_answer_prompt = f"""
+        Based on this solution, what is the final answer only:
+        {thought_process}
+        Give only the final answer, no explanation.
+        """
+        final_answer = self._ask_ai(final_answer_prompt)
+        return {
+            "thought_process": thought_process,
+            "final_answer": final_answer
+        }
+
+    def cot_improve_dict(self, question: str, current_solution: str) -> dict:
+        """
+        Improves the existing solution (text form), returning the best dictionary-based version.
+        """
+        best_solution = {
+            "thought_process": current_solution,
+            "final_answer": current_solution
+        }
+        best_score = self._rate_solution(question, current_solution)
+
+        for _ in range(self.max_attempts):
+            new_solution = self.cot_generate_dict(question, current_solution)
+            new_score = self._rate_solution(question, new_solution["thought_process"])
+            if new_score > best_score:
+                best_solution = new_solution
+                best_score = new_score
+            if best_score > 0.9:
+                break
+        return best_solution
+
+    def cot_run_dict(self, question: str) -> dict:
+        """Uses the dictionary-based solution approach, storing the final solution in self.solutions."""
+        solution = self.cot_generate_dict(question)
+        if self.cot_check(question, solution["final_answer"]):
+            self.solutions[question] = solution
+            return solution
+
+        improved = self.cot_improve_dict(question, solution["thought_process"])
+        if self.cot_check(question, improved["final_answer"]):
+            self.solutions[question] = improved
+            return improved
+
+        error_pos = self.cot_find_error(question, improved["thought_process"])
+        if error_pos != -1:
+            partial_solution = '. '.join(improved["thought_process"].split('. ')[:error_pos]) + '.'
+            final = self.cot_generate_dict(question, partial_solution)
+            self.solutions[question] = final
+            return final
+
+        self.solutions[question] = improved
+        return improved
+
+    def cot_export_json_with_qa_pairs(
+        self,
+        filepath: str = 'dataset.json',
+        save_to_file: bool = True,
+        qa_pairs: Optional[Dict[str, str]] = None
+    ) -> Union[str, list]:
+        """
+        Export solutions in Alpaca training format with their full thought process.
+        """
+        try:
+            self._is_qa_pairs(qa_pairs)  # Validate format
+            if qa_pairs:
+                self.qa_pairs.update(qa_pairs)
+                # Generate solutions if empty
+                if not self.solutions:
+                    for question in qa_pairs:
+                        self.cot_run_dict(question)
+
+            alpaca_data = []
+            for question, sol in self.solutions.items():
+                alpaca_data.append({
+                    "instruction": question,
+                    "input": "",
+                    "output": sol.get("thought_process", "")
+                })
+
+            if not save_to_file:
+                return alpaca_data
+
+            with open(filepath, 'w', encoding='utf-8') as f:
+                json.dump(alpaca_data, f, ensure_ascii=False, indent=2)
+            return filepath
+        except Exception as e:
+            print(f"Error exporting to Alpaca format: {e}")
+            return None
+
+    def cot_export_csv_with_qa_pairs(
+        self,
+        filepath: str = 'dataset.csv',
+        qa_pairs: Optional[Dict[str, str]] = None
+    ) -> Optional[str]:
+        """Export solutions in CSV format."""
+        try:
+            self._is_qa_pairs(qa_pairs)  # Validate format
+            if qa_pairs:
+                self.qa_pairs.update(qa_pairs)
+                # Generate solutions if empty
+                if not self.solutions:
+                    for question in qa_pairs:
+                        self.cot_run_dict(question)
+
+            with open(filepath, 'w', newline='', encoding='utf-8') as f:
+                writer = csv.writer(f)
+                writer.writerow(['instruction', 'input', 'output'])
+                for question, sol in self.solutions.items():
+                    writer.writerow([question, '', sol.get("thought_process", "")])
+            return filepath
+        except Exception as e:
+            print(f"Error exporting to CSV format: {e}")
+            return None
+
+    def cot_save(
+        self,
+        question: str,
+        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.
+        """
+        try:
+            # Remove timestamp-based filename generation since we have default
+            solution = self.cot_run_dict(question)
+            
+            import csv
+            import os
+            file_exists = os.path.exists(filepath)
+
+            with open(filepath, 'a', newline='', encoding='utf-8') as f:
+                writer = csv.writer(f)
+                if not file_exists:
+                    writer.writerow(['instruction', 'input', 'output'])
+                writer.writerow([question, '', solution.get("thought_process", "")])
+            return filepath
+        except Exception as e:
+            print(f"Error appending to CSV: {e}")
+            return None
+
+    # Rename existing function to indicate it handles qa_pairs dictionary
+    def cot_append_csv_with_qa_pairs(
+        self,
+        filepath: str = 'dataset.csv',
+        qa_pairs: Optional[Dict[str, str]] = None
+    ) -> Optional[str]:
+        """Append solutions to CSV file using qa_pairs dictionary."""
+        try:
+            self._is_qa_pairs(qa_pairs)  # Validate format
+            if qa_pairs:
+                self.qa_pairs.update(qa_pairs)
+            
+            import csv
+            import os
+            file_exists = os.path.exists(filepath)
+
+            with open(filepath, 'a', newline='', encoding='utf-8') as f:
+                writer = csv.writer(f)
+                if not file_exists:
+                    writer.writerow(['instruction', 'input', 'output'])
+
+                for question, sol in self.solutions.items():
+                    writer.writerow([question, '', sol.get("thought_process", "")])
+            return filepath
+        except Exception as e:
+            print(f"Error appending to CSV: {e}")
+            return None
+
+    def cot_upload_to_huggingface(
+        self,
+        huggingface_username: str,
+        dataset_name: str,
+        filepath: str,
+        private: bool = False
+    ) -> str:
+        """Upload generated solutions to HuggingFace datasets."""
+        try:
+            from datasets import Dataset
+            from huggingface_hub import HfApi, login
+            import pandas as pd
+            
+            # Determine file type and load data
+            if filepath.endswith('.csv'):
+                data = pd.read_csv(filepath)
+            elif filepath.endswith('.json'):
+                data = pd.read_json(filepath)
+            else:
+                raise ValueError("Only CSV and JSON files are supported")
+                
+            # Convert to HuggingFace dataset
+            dataset = Dataset.from_pandas(data)
+            
+            # Upload to HuggingFace
+            repo_id = f"{huggingface_username}/{dataset_name}"
+            dataset.push_to_hub(
+                repo_id,
+                private=private
+            )
+            
+            return f"Dataset uploaded successfully to {repo_id}"
+            
+        except Exception as e:
+            print(f"Error uploading to HuggingFace: {e}")
+            return None
+
+# Usage example:
+if __name__ == "__main__":
+    # Direct QA Pairs Export Example
+    print("\n=== Direct QA Pairs Export Example ===")
+    direct_qa_data = {
+        "Number of r's in the word strawberry": "3"
+    }
+    
+    direct_generator = GenerateCOT()
+
+    # Export with qa_pairs passed directly to functions
+    direct_generator.cot_export_csv_with_qa_pairs(
+        filepath='direct_solutions.csv',
+        qa_pairs=direct_qa_data
+    )
+    
+    # Example of using cot_save for a single QA pair
+    direct_generator.cot_save(
+        question="What is the capital of France?",
+        answer="Paris",
+        filepath="single_qa.csv"
+    )
+    
+
+    
+    # Upload to HuggingFace
+    direct_generator.cot_upload_to_huggingface(
+        huggingface_username="mervinpraison",
+        dataset_name="cot-test",
+        filepath="single_qa.csv"
+    )
+    
+    # direct_generator.cot_export_json_with_qa_pairs(
+    #     filepath='direct_solutions.json',
+    #     qa_pairs=direct_qa_data
+    # )
+
+    # # Rest of the original examples...
+    # qa_data = {
+    #     "What is 2+2?": "4",
+    #     "How many letters in 'hello'?": "5"
+    # }
+    
+    # generator = GenerateCOT(qa_pairs=qa_data)
+    # for question in qa_data:
+    #     solution = generator.cot_run(question)
+    #     print(f"Question: {question}")
+    #     print(f"Solution: {solution}\n")
+    # answer = generator.cot_run("What is 2+2?")
+    # print(answer)
+
+    # # Additional QA data processing example
+    # print("\n=== Processing Additional QA Data ===")
+    # extra_qa_data = {
+
+    #     "What is 5 * 3?": "15"
+    # }
+    
+    # # Create separate generator for additional data
+    # extra_generator = GenerateCOT(qa_pairs=extra_qa_data)
+    
+    # # Process and save solutions
+    # for question in extra_qa_data:
+    #     solution = extra_generator.cot_run_dict(question)
+    #     print(f"Processing extra question: {question}")
+    
+    # # Save solutions separately
+    # extra_generator.cot_save_solutions_with_qa_pairs('extra_qa_solutions.json')
+    
+    # # Export in Alpaca format
+    # extra_generator.cot_export_json_with_qa_pairs(filepath='extra_qa_alpaca.json', save_to_file=True)
+    
+    # # Demonstrate loading saved data
+    # loaded_generator = GenerateCOT(qa_pairs={})
+    # loaded_generator.cot_load_answers('extra_qa_solutions.json')
+    # print("\nLoaded extra QA pairs:", loaded_generator.qa_pairs)

{praisonaiagents-0.0.54.dist-info → praisonaiagents-0.0.57.dist-info}/METADATA

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

{praisonaiagents-0.0.54.dist-info → praisonaiagents-0.0.57.dist-info}/RECORD

@@ -1,7 +1,7 @@
 praisonaiagents/__init__.py,sha256=JtPibbmeFv3meIb3vkKjckB0p7m-Vqt2RYPwOH8P41k,1228
 praisonaiagents/main.py,sha256=0kB9gn9meXtr4EIrdgA2lAioKIHCRJ61audsGDwuTm4,14428
 praisonaiagents/agent/__init__.py,sha256=sKO8wGEXvtCrvV1e834r1Okv0XAqAxqZCqz6hKLiTvA,79
-praisonaiagents/agent/agent.py,sha256=Rd2ZCToraAoe57UDT1JfrB03ffRKtZ-Tct9avFcZyT4,54257
+praisonaiagents/agent/agent.py,sha256=VZPci7g_LAvTz7_rWvWAZ1JgCGKQc1vSfI6x0fqi2os,57598
 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
@@ -9,13 +9,13 @@ praisonaiagents/knowledge/__init__.py,sha256=xL1Eh-a3xsHyIcU4foOWF-JdWYIYBALJH9b
 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=M6xh9cuO0KZjzpAkHZrnktxw4eCmXLymoZqMoXeq-0U,50352
+praisonaiagents/llm/llm.py,sha256=G2wKMwitWBJRS6nOq9W77zXtsxvJwsVwXFOKYcllY0E,51386
 praisonaiagents/memory/memory.py,sha256=I8dOTkrl1i-GgQbDcrFOsSruzJ7MiI6Ys37DK27wrUs,35537
 praisonaiagents/process/__init__.py,sha256=lkYbL7Hn5a0ldvJtkdH23vfIIZLIcanK-65C0MwaorY,52
-praisonaiagents/process/process.py,sha256=_1Nk37kOYakPaUWAJff86rP0ENyykXqMnhTp8E0efuE,30802
+praisonaiagents/process/process.py,sha256=gP3QQxxFO4oUw_HYLf8MoyWyaj_104LIL_AbwLiBxaU,31261
 praisonaiagents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
 praisonaiagents/task/task.py,sha256=ikFjzNm4WPYONSLtWA3uDGNIUx_TvXTeU5SukWoC66E,14271
-praisonaiagents/tools/__init__.py,sha256=-0lV5n5cG54vYW6REjXIfuJnCLKnfQIDlXsySCaPB9s,7347
+praisonaiagents/tools/__init__.py,sha256=CWOYV9SudYY82r45LnNgaVRV3cmsAFdasNRkPrLsgmI,9198
 praisonaiagents/tools/arxiv_tools.py,sha256=1stb31zTjLTon4jCnpZG5de9rKc9QWgC0leLegvPXWo,10528
 praisonaiagents/tools/calculator_tools.py,sha256=S1xPT74Geurvjm52QMMIG29zDXVEWJmM6nmyY7yF298,9571
 praisonaiagents/tools/csv_tools.py,sha256=gX2nYz4ktmpKvXB36jx5-GqddntEQD4G2fVQWTIKrwU,8435
@@ -35,7 +35,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-0.0.54.dist-info/METADATA,sha256=Zfzek1Y53OzW35U-lLAX5mTpdS0xxV57mCDdHhcSfYo,830
-praisonaiagents-0.0.54.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-praisonaiagents-0.0.54.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.54.dist-info/RECORD,,
+praisonaiagents/tools/train/data/generatecot.py,sha256=HA8HwbhGIavfALxMbKTdGwABP5S6qzuiPtmUiV-FTZI,17491
+praisonaiagents-0.0.57.dist-info/METADATA,sha256=ad3iyUlLBQqjpuTcbka6Z6MAX57RaJGRbkifyYEhz-w,830
+praisonaiagents-0.0.57.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+praisonaiagents-0.0.57.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.57.dist-info/RECORD,,