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

praisonaiagents/process/process.py

@@ -13,6 +13,13 @@ class LoopItems(BaseModel):
 
 class Process:
     def __init__(self, tasks: Dict[str, Task], agents: List[Agent], manager_llm: Optional[str] = None, verbose: bool = False, max_iter: int = 10):
+        logging.debug(f"=== Initializing Process ===")
+        logging.debug(f"Number of tasks: {len(tasks)}")
+        logging.debug(f"Number of agents: {len(agents)}")
+        logging.debug(f"Manager LLM: {manager_llm}")
+        logging.debug(f"Verbose mode: {verbose}")
+        logging.debug(f"Max iterations: {max_iter}")
+        
         self.tasks = tasks
         self.agents = agents
         self.manager_llm = manager_llm
@@ -21,25 +28,30 @@ class Process:
 
     async def aworkflow(self) -> AsyncGenerator[str, None]:
         """Async version of workflow method"""
+        logging.debug("=== Starting Async Workflow ===")
         current_iter = 0  # Track how many times we've looped
         # Build workflow relationships first
+        logging.debug("Building workflow relationships...")
         for task in self.tasks.values():
             if task.next_tasks:
                 for next_task_name in task.next_tasks:
                     next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
                     if next_task:
                         next_task.previous_tasks.append(task.name)
+                        logging.debug(f"Added {task.name} as previous task for {next_task_name}")
 
         # Find start task
+        logging.debug("Finding start task...")
         start_task = None
         for task_id, task in self.tasks.items():
             if task.is_start:
                 start_task = task
+                logging.debug(f"Found marked start task: {task.name} (id: {task_id})")
                 break
         
         if not start_task:
             start_task = list(self.tasks.values())[0]
-            logging.info("No start task marked, using first task")
+            logging.debug(f"No start task marked, using first task: {start_task.name}")
         
         current_task = start_task
         visited_tasks = set()
@@ -54,7 +66,16 @@ class Process:
                 break
 
             task_id = current_task.id
-            logging.info(f"Executing workflow task: {current_task.name if current_task.name else task_id}")
+            logging.debug(f"""
+=== Task Execution Details ===
+Current task: {current_task.name}
+Type: {current_task.task_type}
+Status: {current_task.status}
+Previous tasks: {current_task.previous_tasks}
+Next tasks: {current_task.next_tasks}
+Context tasks: {[t.name for t in current_task.context] if current_task.context else []}
+Description length: {len(current_task.description)}
+            """)
             
             # Add context from previous tasks to description
             if current_task.previous_tasks or current_task.context:
@@ -66,46 +87,6 @@ class Process:
                     if prev_task and prev_task.result:
                         # Handle loop data
                         if current_task.task_type == "loop":
-#                             # create a loop manager Agent
-#                             loop_manager = Agent(
-#                                 name="Loop Manager",
-#                                 role="Loop data processor",
-#                                 goal="Process loop data and convert it to list format",
-#                                 backstory="Expert at handling loop data and converting it to proper format",
-#                                 llm=self.manager_llm,
-#                                 verbose=self.verbose,
-#                                 markdown=True
-#                             )
-
-#                             # get the loop data convert it to list using calling Agent class chat
-#                             loop_prompt = f"""
-# Process this data into a list format:
-# {prev_task.result.raw}
-
-# Return a JSON object with an 'items' array containing the items to process.
-# """
-#                             if current_task.async_execution:
-#                                 loop_data_str = await loop_manager.achat(
-#                                     prompt=loop_prompt,
-#                                     output_json=LoopItems
-#                                 )
-#                             else:
-#                                 loop_data_str = loop_manager.chat(
-#                                     prompt=loop_prompt,
-#                                     output_json=LoopItems
-#                                 )
-                            
-#                             try:
-#                                 # The response will already be parsed into LoopItems model
-#                                 loop_data[f"loop_{current_task.name}"] = {
-#                                     "items": loop_data_str.items,
-#                                     "index": 0,
-#                                     "remaining": len(loop_data_str.items)
-#                                 }
-#                                 context += f"\nCurrent loop item: {loop_data_str.items[0]}"
-#                             except Exception as e:
-#                                 display_error(f"Failed to process loop data: {e}")
-#                                 context += f"\n{prev_name}: {prev_task.result.raw}"
                             context += f"\n{prev_name}: {prev_task.result.raw}"
                         else:
                             context += f"\n{prev_name}: {prev_task.result.raw}"
@@ -119,14 +100,103 @@ class Process:
                 # Update task description with context
                 current_task.description = current_task.description + context
             
-            # Execute task using existing run_task method
-            yield task_id
-            visited_tasks.add(task_id)
+            # Skip execution for loop tasks, only process their subtasks
+            if current_task.task_type == "loop":
+                logging.debug(f"""
+=== Loop Task Details ===
+Name: {current_task.name}
+ID: {current_task.id}
+Status: {current_task.status}
+Next tasks: {current_task.next_tasks}
+Condition: {current_task.condition}
+Subtasks created: {getattr(current_task, '_subtasks_created', False)}
+Input file: {getattr(current_task, 'input_file', None)}
+                """)
+                
+                # Check if subtasks are created and completed
+                if getattr(current_task, "_subtasks_created", False):
+                    subtasks = [
+                        t for t in self.tasks.values()
+                        if t.name.startswith(current_task.name + "_")
+                    ]
+                    logging.debug(f"""
+=== Subtask Status Check ===
+Total subtasks: {len(subtasks)}
+Completed: {sum(1 for st in subtasks if st.status == "completed")}
+Pending: {sum(1 for st in subtasks if st.status != "completed")}
+                    """)
+                    
+                    # Log detailed subtask info
+                    for st in subtasks:
+                        logging.debug(f"""
+Subtask: {st.name}
+- Status: {st.status}
+- Next tasks: {st.next_tasks}
+- Condition: {st.condition}
+                        """)
+                    
+                    if subtasks and all(st.status == "completed" for st in subtasks):
+                        logging.debug(f"=== All {len(subtasks)} subtasks completed for {current_task.name} ===")
+                        
+                        # Mark loop task completed and move to next task
+                        current_task.status = "completed"
+                        logging.debug(f"Loop {current_task.name} marked as completed")
+                        
+                        # Move to next task if available
+                        if current_task.next_tasks:
+                            next_task_name = current_task.next_tasks[0]
+                            logging.debug(f"Attempting transition to next task: {next_task_name}")
+                            next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
+                            if next_task:
+                                logging.debug(f"=== Transitioning: {current_task.name} -> {next_task.name} ===")
+                                logging.debug(f"Next task status: {next_task.status}")
+                                logging.debug(f"Next task condition: {next_task.condition}")
+                            current_task = next_task
+                        else:
+                            logging.debug(f"=== No next tasks for {current_task.name}, ending loop ===")
+                            current_task = None
+                else:
+                    logging.debug(f"No subtasks created yet for {current_task.name}")
+                    # Create subtasks if needed
+                    if current_task.input_file:
+                        self._create_loop_subtasks(current_task)
+                        current_task._subtasks_created = True
+                        logging.debug(f"Created subtasks from {current_task.input_file}")
+                    else:
+                        # No input file, mark as done
+                        current_task.status = "completed"
+                        logging.debug(f"No input file, marking {current_task.name} as completed")
+                        if current_task.next_tasks:
+                            next_task_name = current_task.next_tasks[0]
+                            next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
+                            current_task = next_task
+                        else:
+                            current_task = None
+            else:
+                # Execute non-loop task
+                logging.debug(f"=== Executing non-loop task: {current_task.name} (id: {task_id}) ===")
+                logging.debug(f"Task status: {current_task.status}")
+                logging.debug(f"Task next_tasks: {current_task.next_tasks}")
+                yield task_id
+                visited_tasks.add(task_id)
             
             # Reset completed task to "not started" so it can run again
             if self.tasks[task_id].status == "completed":
-                logging.debug(f"Task {task_id} was completed, resetting to 'not started' for next iteration.")
-                self.tasks[task_id].status = "not started"
+                # Never reset loop tasks, decision tasks, or their subtasks
+                subtask_name = self.tasks[task_id].name
+                logging.debug(f"=== Checking reset for completed task: {subtask_name} ===")
+                logging.debug(f"Task type: {self.tasks[task_id].task_type}")
+                logging.debug(f"Task status before reset check: {self.tasks[task_id].status}")
+                
+                if (self.tasks[task_id].task_type not in ["loop", "decision"] and
+                    not any(t.task_type == "loop" and subtask_name.startswith(t.name + "_") 
+                           for t in self.tasks.values())):
+                    logging.debug(f"=== Resetting non-loop, non-decision task {subtask_name} to 'not started' ===")
+                    self.tasks[task_id].status = "not started"
+                    logging.debug(f"Task status after reset: {self.tasks[task_id].status}")
+                else:
+                    logging.debug(f"=== Skipping reset for loop/decision/subtask: {subtask_name} ===")
+                    logging.debug(f"Keeping status as: {self.tasks[task_id].status}")
             
             # Handle loop progression
             if current_task.task_type == "loop":
@@ -179,6 +249,15 @@ class Process:
                 logging.info("Workflow execution completed")
                 break
 
+            # Add completion logging
+            logging.debug(f"""
+=== Task Completion ===
+Task: {current_task.name}
+Final status: {current_task.status}
+Next task: {next_task.name if next_task else None}
+Iteration: {current_iter}/{self.max_iter}
+            """)
+
     async def asequential(self) -> AsyncGenerator[str, None]:
         """Async version of sequential method"""
         for task_id in self.tasks:
@@ -343,33 +422,59 @@ Provide a JSON with the structure:
                 new_tasks = []
                 
                 if file_ext == ".csv":
-                    # existing CSV reading logic
                     with open(start_task.input_file, "r", encoding="utf-8") as f:
-                        # Try as simple CSV first
-                        reader = csv.reader(f)
+                        reader = csv.reader(f, quotechar='"', escapechar='\\')  # Handle quoted/escaped fields
                         previous_task = None
+                        task_count = 0
+                        
                         for i, row in enumerate(reader):
-                            if row:  # Skip empty rows
-                                task_desc = row[0]  # Take first column
-                                row_task = Task(
-                                    description=f"{start_task.description}\n{task_desc}" if start_task.description else task_desc,
-                                    agent=start_task.agent,
-                                    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={
-                                        "complete": ["next"],
-                                        "retry": ["current"]
-                                    }
-                                )
-                                self.tasks[row_task.id] = row_task
-                                new_tasks.append(row_task)
+                            if not row:  # Skip truly empty rows
+                                continue
                                 
-                                if previous_task:
-                                    previous_task.next_tasks = [row_task.name]
-                                    previous_task.condition["complete"] = [row_task.name]
-                                previous_task = row_task
+                            # Properly handle Q&A pairs with potential commas
+                            task_desc = row[0].strip() if row else ""
+                            if len(row) > 1:
+                                # Preserve all fields in case of multiple commas
+                                question = row[0].strip()
+                                answer = ",".join(field.strip() for field in row[1:])
+                                task_desc = f"Question: {question}\nAnswer: {answer}"
+                            
+                            if not task_desc:  # Skip rows with empty content
+                                continue
+                                
+                            task_count += 1
+                            logging.debug(f"Processing CSV row {i+1}: {task_desc}")
+                            
+                            # Inherit next_tasks from parent loop task
+                            inherited_next_tasks = start_task.next_tasks if start_task.next_tasks else []
+                            
+                            row_task = Task(
+                                description=f"{start_task.description}\n{task_desc}" if start_task.description else task_desc,
+                                agent=start_task.agent,
+                                name=f"{start_task.name}_{task_count}" if start_task.name else task_desc,
+                                expected_output=getattr(start_task, 'expected_output', None),
+                                is_start=(task_count == 1),
+                                task_type="decision",  # Change to decision type
+                                next_tasks=inherited_next_tasks,  # Inherit parent's next tasks
+                                condition={
+                                    "done": inherited_next_tasks if inherited_next_tasks else ["next"],  # Use full inherited_next_tasks
+                                    "retry": ["current"],
+                                    "exit": []  # Empty list for exit condition
+                                }
+                            )
+                            self.tasks[row_task.id] = row_task
+                            new_tasks.append(row_task)
+                            
+                            if previous_task:
+                                previous_task.next_tasks = [row_task.name]
+                                previous_task.condition["done"] = [row_task.name]  # Use "done" consistently
+                            previous_task = row_task
+                            
+                            # For the last task in the loop, ensure it points to parent's next tasks
+                            if task_count > 0 and not row_task.next_tasks:
+                                row_task.next_tasks = inherited_next_tasks
+                            
+                        logging.info(f"Processed {task_count} rows from CSV file")
                 else:
                     # If not CSV, read lines
                     with open(start_task.input_file, "r", encoding="utf-8") as f:
@@ -402,7 +507,7 @@ Provide a JSON with the structure:
             except Exception as e:
                 logging.error(f"Failed to read file tasks: {e}")
 
-        # end of the new block
+        # end of start task handling
         current_task = start_task
         visited_tasks = set()
         loop_data = {}  # Store loop-specific data
@@ -413,8 +518,88 @@ Provide a JSON with the structure:
                 logging.info(f"Max iteration limit {self.max_iter} reached, ending workflow.")
                 break
 
+            # Handle loop task file reading at runtime
+            if (current_task.task_type == "loop" and 
+                current_task is not start_task and 
+                getattr(current_task, "_subtasks_created", False) is not True):
+                
+                if not current_task.input_file:
+                    current_task.input_file = "tasks.csv"
+                
+                if getattr(current_task, "input_file", None):
+                    try:
+                        file_ext = os.path.splitext(current_task.input_file)[1].lower()
+                        new_tasks = []
+                        
+                        if file_ext == ".csv":
+                            with open(current_task.input_file, "r", encoding="utf-8") as f:
+                                reader = csv.reader(f)
+                                previous_task = None
+                                for i, row in enumerate(reader):
+                                    if row:  # Skip empty rows
+                                        task_desc = row[0]  # Take first column
+                                        row_task = Task(
+                                            description=f"{current_task.description}\n{task_desc}" if current_task.description else task_desc,
+                                            agent=current_task.agent,
+                                            name=f"{current_task.name}_{i+1}" if current_task.name else task_desc,
+                                            expected_output=getattr(current_task, 'expected_output', None),
+                                            is_start=(i == 0),
+                                            task_type="task",
+                                            condition={
+                                                "complete": ["next"],
+                                                "retry": ["current"]
+                                            }
+                                        )
+                                        self.tasks[row_task.id] = row_task
+                                        new_tasks.append(row_task)
+                                        
+                                        if previous_task:
+                                            previous_task.next_tasks = [row_task.name]
+                                            previous_task.condition["complete"] = [row_task.name]
+                                        previous_task = row_task
+                        else:
+                            with open(current_task.input_file, "r", encoding="utf-8") as f:
+                                lines = f.read().splitlines()
+                                previous_task = None
+                                for i, line in enumerate(lines):
+                                    row_task = Task(
+                                        description=f"{current_task.description}\n{line.strip()}" if current_task.description else line.strip(),
+                                        agent=current_task.agent,
+                                        name=f"{current_task.name}_{i+1}" if current_task.name else line.strip(),
+                                        expected_output=getattr(current_task, 'expected_output', None),
+                                        is_start=(i == 0),
+                                        task_type="task",
+                                        condition={
+                                            "complete": ["next"],
+                                            "retry": ["current"]
+                                        }
+                                    )
+                                    self.tasks[row_task.id] = row_task
+                                    new_tasks.append(row_task)
+                                    
+                                    if previous_task:
+                                        previous_task.next_tasks = [row_task.name]
+                                        previous_task.condition["complete"] = [row_task.name]
+                                    previous_task = row_task
+
+                        if new_tasks:
+                            current_task.next_tasks = [new_tasks[0].name]
+                            current_task._subtasks_created = True
+                            logging.info(f"Created {len(new_tasks)} tasks from: {current_task.input_file} for loop task {current_task.name}")
+                    except Exception as e:
+                        logging.error(f"Failed to read file tasks for loop task {current_task.name}: {e}")
+
             task_id = current_task.id
-            logging.info(f"Executing workflow task: {current_task.name if current_task.name else task_id}")
+            logging.debug(f"""
+=== Task Execution Details ===
+Current task: {current_task.name}
+Type: {current_task.task_type}
+Status: {current_task.status}
+Previous tasks: {current_task.previous_tasks}
+Next tasks: {current_task.next_tasks}
+Context tasks: {[t.name for t in current_task.context] if current_task.context else []}
+Description length: {len(current_task.description)}
+            """)
             
             # Add context from previous tasks to description
             if current_task.previous_tasks or current_task.context:
@@ -426,40 +611,6 @@ Provide a JSON with the structure:
                     if prev_task and prev_task.result:
                         # Handle loop data
                         if current_task.task_type == "loop":
-#                             # create a loop manager Agent
-#                             loop_manager = Agent(
-#                                 name="Loop Manager",
-#                                 role="Loop data processor",
-#                                 goal="Process loop data and convert it to list format",
-#                                 backstory="Expert at handling loop data and converting it to proper format",
-#                                 llm=self.manager_llm,
-#                                 verbose=self.verbose,
-#                                 markdown=True
-#                             )
-
-#                             # get the loop data convert it to list using calling Agent class chat
-#                             loop_prompt = f"""
-# Process this data into a list format:
-# {prev_task.result.raw}
-
-# Return a JSON object with an 'items' array containing the items to process.
-# """
-#                             loop_data_str = loop_manager.chat(
-#                                 prompt=loop_prompt,
-#                                 output_json=LoopItems
-#                             )
-                            
-#                             try:
-#                                 # The response will already be parsed into LoopItems model
-#                                 loop_data[f"loop_{current_task.name}"] = {
-#                                     "items": loop_data_str.items,
-#                                     "index": 0,
-#                                     "remaining": len(loop_data_str.items)
-#                                 }
-#                                 context += f"\nCurrent loop item: {loop_data_str.items[0]}"
-#                             except Exception as e:
-#                                 display_error(f"Failed to process loop data: {e}")
-#                                 context += f"\n{prev_name}: {prev_task.result.raw}"
                             context += f"\n{prev_name}: {prev_task.result.raw}"
                         else:
                             context += f"\n{prev_name}: {prev_task.result.raw}"
@@ -473,14 +624,103 @@ Provide a JSON with the structure:
                 # Update task description with context
                 current_task.description = current_task.description + context
             
-            # Execute task using existing run_task method
-            yield task_id
-            visited_tasks.add(task_id)
+            # Skip execution for loop tasks, only process their subtasks
+            if current_task.task_type == "loop":
+                logging.debug(f"""
+=== Loop Task Details ===
+Name: {current_task.name}
+ID: {current_task.id}
+Status: {current_task.status}
+Next tasks: {current_task.next_tasks}
+Condition: {current_task.condition}
+Subtasks created: {getattr(current_task, '_subtasks_created', False)}
+Input file: {getattr(current_task, 'input_file', None)}
+                """)
+                
+                # Check if subtasks are created and completed
+                if getattr(current_task, "_subtasks_created", False):
+                    subtasks = [
+                        t for t in self.tasks.values()
+                        if t.name.startswith(current_task.name + "_")
+                    ]
+                    
+                    logging.debug(f"""
+=== Subtask Status Check ===
+Total subtasks: {len(subtasks)}
+Completed: {sum(1 for st in subtasks if st.status == "completed")}
+Pending: {sum(1 for st in subtasks if st.status != "completed")}
+                    """)
+
+                    for st in subtasks:
+                        logging.debug(f"""
+Subtask: {st.name}
+- Status: {st.status}
+- Next tasks: {st.next_tasks}
+- Condition: {st.condition}
+                        """)
+
+                    if subtasks and all(st.status == "completed" for st in subtasks):
+                        logging.debug(f"=== All {len(subtasks)} subtasks completed for {current_task.name} ===")
+                        
+                        # Mark loop task completed and move to next task
+                        current_task.status = "completed"
+                        logging.debug(f"Loop {current_task.name} marked as completed")
+                        
+                        # Move to next task if available
+                        if current_task.next_tasks:
+                            next_task_name = current_task.next_tasks[0]
+                            logging.debug(f"Attempting transition to next task: {next_task_name}")
+                            next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
+                            if next_task:
+                                logging.debug(f"=== Transitioning: {current_task.name} -> {next_task.name} ===")
+                                logging.debug(f"Next task status: {next_task.status}")
+                                logging.debug(f"Next task condition: {next_task.condition}")
+                            current_task = next_task
+                        else:
+                            logging.debug(f"=== No next tasks for {current_task.name}, ending loop ===")
+                            current_task = None
+                else:
+                    logging.debug(f"No subtasks created yet for {current_task.name}")
+                    # Create subtasks if needed
+                    if current_task.input_file:
+                        self._create_loop_subtasks(current_task)
+                        current_task._subtasks_created = True
+                        logging.debug(f"Created subtasks from {current_task.input_file}")
+                    else:
+                        # No input file, mark as done
+                        current_task.status = "completed"
+                        logging.debug(f"No input file, marking {current_task.name} as completed")
+                        if current_task.next_tasks:
+                            next_task_name = current_task.next_tasks[0]
+                            next_task = next((t for t in self.tasks.values() if t.name == next_task_name), None)
+                            current_task = next_task
+                        else:
+                            current_task = None
+            else:
+                # Execute non-loop task
+                logging.debug(f"=== Executing non-loop task: {current_task.name} (id: {task_id}) ===")
+                logging.debug(f"Task status: {current_task.status}")
+                logging.debug(f"Task next_tasks: {current_task.next_tasks}")
+                yield task_id
+                visited_tasks.add(task_id)
             
-            # Reset completed task to "not started" so it can run again: Only for workflow because some tasks may be revisited
+            # Reset completed task to "not started" so it can run again
             if self.tasks[task_id].status == "completed":
-                logging.debug(f"Task {task_id} was completed, resetting to 'not started' for next iteration.")
-                self.tasks[task_id].status = "not started"
+                # Never reset loop tasks, decision tasks, or their subtasks
+                subtask_name = self.tasks[task_id].name
+                logging.debug(f"=== Checking reset for completed task: {subtask_name} ===")
+                logging.debug(f"Task type: {self.tasks[task_id].task_type}")
+                logging.debug(f"Task status before reset check: {self.tasks[task_id].status}")
+                
+                if (self.tasks[task_id].task_type not in ["loop", "decision"] and
+                    not any(t.task_type == "loop" and subtask_name.startswith(t.name + "_") 
+                           for t in self.tasks.values())):
+                    logging.debug(f"=== Resetting non-loop, non-decision task {subtask_name} to 'not started' ===")
+                    self.tasks[task_id].status = "not started"
+                    logging.debug(f"Task status after reset: {self.tasks[task_id].status}")
+                else:
+                    logging.debug(f"=== Skipping reset for loop/decision/subtask: {subtask_name} ===")
+                    logging.debug(f"Keeping status as: {self.tasks[task_id].status}")
             
             # Handle loop progression
             if current_task.task_type == "loop":

praisonaiagents/tools/csv_tools.py

@@ -89,7 +89,7 @@ class CSVTools:
     def write_csv(
         self,
         filepath: str,
-        data: List[Dict[str, Any]],
+        data: Union[List[Dict[str, Any]], str],
         encoding: str = 'utf-8',
         delimiter: str = ',',
         index: bool = False,
@@ -102,35 +102,66 @@ class CSVTools:
         
         Args:
             filepath: Path to CSV file
-            data: List of row dicts to write
-            encoding: File encoding
-            delimiter: Column delimiter
-            index: Whether to write row indices
-            header: Whether to write column headers
-            float_format: Format string for float values
-            date_format: Format string for date values
-            mode: Write mode ('w' for write, 'a' for append)
-            
+            data: Either a list of dictionaries or a string containing CSV data
+                  If string, each line should be comma-separated values
+            encoding: File encoding (default: 'utf-8')
+            delimiter: Column delimiter (default: ',')
+            index: Whether to write row indices (default: False)
+            header: Whether to write column headers (default: True)
+            float_format: Format string for float values (default: None)
+            date_format: Format string for date values (default: None)
+            mode: Write mode - 'w' for write, 'a' for append (default: 'w')
+        
         Returns:
-            bool: Success status
+            bool: True if successful, False otherwise
         """
         try:
             pd = self._get_pandas()
             if pd is None:
                 return False
 
-            df = pd.DataFrame(data)
-            df.to_csv(
-                filepath,
-                encoding=encoding,
-                sep=delimiter,
-                index=index,
-                header=header,
-                float_format=float_format,
-                date_format=date_format,
-                mode=mode
-            )
-            return True
+            # Handle string input
+            if isinstance(data, str):
+                # Convert string to list of dicts
+                rows = []
+                if delimiter in data:
+                    # Get existing columns if file exists and in append mode
+                    existing_cols = []
+                    if mode == 'a' and Path(filepath).exists():
+                        try:
+                            existing_df = pd.read_csv(filepath, nrows=1)
+                            existing_cols = existing_df.columns.tolist()
+                        except:
+                            pass
+
+                    values = [v.strip() for v in data.split(delimiter)]
+                    
+                    if existing_cols:
+                        # Use existing column names
+                        row_dict = dict(zip(existing_cols, values))
+                    else:
+                        # Create generic column names
+                        row_dict = {f'col{i}': val for i, val in enumerate(values)}
+                    
+                    rows.append(row_dict)
+                    data = rows
+
+                df = pd.DataFrame(data)
+                
+                # Handle append mode properly
+                write_header = header if mode == 'w' else (header and not Path(filepath).exists())
+                
+                df.to_csv(
+                    filepath,
+                    encoding=encoding,
+                    sep=delimiter,
+                    index=index,
+                    header=write_header,
+                    float_format=float_format,
+                    date_format=date_format,
+                    mode=mode
+                )
+                return True
             
         except Exception as e:
             error_msg = f"Error writing CSV file {filepath}: {str(e)}"

praisonaiagents/tools/train/data/generatecot.py

@@ -21,7 +21,7 @@ class GenerateCOT:
         qa_pairs: Optional[Dict[str, str]] = None,
         model: str = "gpt-4o-mini",
         api_key: Optional[str] = None,
-        max_attempts: int = 100
+        max_attempts: int = 3
     ):
         self.qa_pairs = qa_pairs or {}
         self.max_attempts = max_attempts
@@ -79,8 +79,10 @@ class GenerateCOT:
     def cot_improve(self, question: str, current: str) -> str:
         best_solution = current
         best_score = self._rate_solution(question, current)
+        attempts = 0
         
-        for _ in range(self.max_attempts):
+        while attempts < self.max_attempts:
+            attempts += 1
             new_solution = self.cot_generate(question, current)
             new_score = self._rate_solution(question, new_solution)
             
@@ -88,7 +90,7 @@ class GenerateCOT:
                 best_solution = new_solution
                 best_score = new_score
                 
-            if best_score > 0.9:
+            if best_score > 0.8:
                 break
                 
         return best_solution
@@ -228,14 +230,16 @@ class GenerateCOT:
             "final_answer": current_solution
         }
         best_score = self._rate_solution(question, current_solution)
+        attempts = 0
 
-        for _ in range(self.max_attempts):
+        while attempts < self.max_attempts:
+            attempts += 1
             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:
+            if best_score > 0.8:
                 break
         return best_solution
 
@@ -333,7 +337,10 @@ class GenerateCOT:
         Creates file with headers if it doesn't exist.
         """
         try:
-            # Remove timestamp-based filename generation since we have default
+            # Add the current QA pair to self.qa_pairs
+            self.qa_pairs[question] = answer
+            
+            # Generate solution
             solution = self.cot_run_dict(question)
             
             import csv

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

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

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

@@ -12,13 +12,13 @@ praisonaiagents/llm/__init__.py,sha256=ttPQQJQq6Tah-0updoEXDZFKWtJAM93rBWRoIgxRW
 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=gP3QQxxFO4oUw_HYLf8MoyWyaj_104LIL_AbwLiBxaU,31261
+praisonaiagents/process/process.py,sha256=BrS8_4Gt2ewXt559hThJTSrXVYG8daabO9tGDaWmrm0,44906
 praisonaiagents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
 praisonaiagents/task/task.py,sha256=ikFjzNm4WPYONSLtWA3uDGNIUx_TvXTeU5SukWoC66E,14271
 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
+praisonaiagents/tools/csv_tools.py,sha256=4Yr0QYwBXt-1BDXGLalB2eSsFR2mB5rH3KdHmRBQY6E,10036
 praisonaiagents/tools/duckdb_tools.py,sha256=KB3b-1HcX7ocoxskDpk_7RRpTGHnH8hizIY0ZdLRbIE,8816
 praisonaiagents/tools/duckduckgo_tools.py,sha256=ynlB5ZyWfHYjUq0JZXH12TganqTihgD-2IyRgs32y84,1657
 praisonaiagents/tools/excel_tools.py,sha256=e2HqcwnyBueOyss0xEKxff3zB4w4sNWCOMXvZfbDYlE,11309
@@ -35,8 +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/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,,
+praisonaiagents/tools/train/data/generatecot.py,sha256=k1gZHtgY1poVp5kajhgs4S9a4-epdA8NyZfYTa34lQU,17651
+praisonaiagents-0.0.58.dist-info/METADATA,sha256=N_DIe_TPq4gXuySMSwVSPpsSarqo7h-_fTAIQaRFGT0,830
+praisonaiagents-0.0.58.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+praisonaiagents-0.0.58.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.58.dist-info/RECORD,,