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

praisonaiagents/task/task.py

@@ -38,7 +38,8 @@ class Task:
         loop_state: Optional[Dict[str, Union[str, int]]] = None,
         memory=None,
         quality_check=True,
-        input_file: Optional[str] = None
+        input_file: Optional[str] = None,
+        rerun: bool = False # Renamed from can_rerun and logic inverted, default True for backward compatibility
     ):
         # Add check if memory config is provided
         if memory is not None or (config and config.get('memory_config')):
@@ -76,6 +77,7 @@ class Task:
         self.loop_state = loop_state if loop_state else {}
         self.memory = memory
         self.quality_check = quality_check
+        self.rerun = rerun # Assigning the rerun parameter
 
         # Set logger level based on config verbose level
         verbose = self.config.get("verbose", 0)
@@ -83,7 +85,7 @@ class Task:
             logger.setLevel(logging.INFO)
         else:
             logger.setLevel(logging.WARNING)
-            
+
         # Also set third-party loggers to WARNING
         logging.getLogger('chromadb').setLevel(logging.WARNING)
         logging.getLogger('openai').setLevel(logging.WARNING)
@@ -148,7 +150,7 @@ class Task:
                 logger.info(f"Task {self.id}: Initializing memory from config: {self.config['memory_config']}")
                 self.memory = Memory(config=self.config['memory_config'])
                 logger.info(f"Task {self.id}: Memory initialized successfully")
-                
+
                 # Verify database was created
                 if os.path.exists(self.config['memory_config']['storage']['path']):
                     logger.info(f"Task {self.id}: Memory database exists after initialization")
@@ -182,11 +184,11 @@ class Task:
         """Execute callback and store quality metrics if enabled"""
         logger.info(f"Task {self.id}: execute_callback called")
         logger.info(f"Quality check enabled: {self.quality_check}")
-        
+
         # Initialize memory if not already initialized
         if not self.memory:
             self.memory = self.initialize_memory()
-        
+
         logger.info(f"Memory object exists: {self.memory is not None}")
         if self.memory:
             logger.info(f"Memory config: {self.memory.cfg}")
@@ -202,24 +204,24 @@ class Task:
             except Exception as e:
                 logger.error(f"Task {self.id}: Failed to store task output in memory: {e}")
                 logger.exception(e)
-        
+
         logger.info(f"Task output: {task_output.raw[:100]}...")
-        
+
         if self.quality_check and self.memory:
             try:
                 logger.info(f"Task {self.id}: Starting memory operations")
                 logger.info(f"Task {self.id}: Calculating quality metrics for output: {task_output.raw[:100]}...")
-                
+
                 # Get quality metrics from LLM
                 metrics = self.memory.calculate_quality_metrics(
                     task_output.raw,
                     self.expected_output
                 )
                 logger.info(f"Task {self.id}: Quality metrics calculated: {metrics}")
-                
+
                 quality_score = metrics.get("accuracy", 0.0)
                 logger.info(f"Task {self.id}: Quality score: {quality_score}")
-                
+
                 # Store in both short and long-term memory with higher threshold
                 logger.info(f"Task {self.id}: Finalizing task output in memory...")
                 self.memory.finalize_task_output(
@@ -231,7 +233,7 @@ class Task:
                     task_id=self.id
                 )
                 logger.info(f"Task {self.id}: Finalized task output in memory")
-                
+
                 # Store quality metrics separately
                 logger.info(f"Task {self.id}: Storing quality metrics...")
                 self.memory.store_quality(
@@ -240,7 +242,7 @@ class Task:
                     task_id=self.id,
                     metrics=metrics
                 )
-                
+
                 # Store in both short and long-term memory with higher threshold
                 self.memory.finalize_task_output(
                     content=task_output.raw,
@@ -248,7 +250,7 @@ class Task:
                     quality_score=quality_score,
                     threshold=0.7  # Only high quality outputs in long-term memory
                 )
-                
+
                 # Build context for next tasks
                 if self.next_tasks:
                     logger.info(f"Task {self.id}: Building context for next tasks...")
@@ -257,7 +259,7 @@ class Task:
                         max_items=5
                     )
                     logger.info(f"Task {self.id}: Built context for next tasks: {len(context)} items")
-                
+
                 logger.info(f"Task {self.id}: Memory operations complete")
             except Exception as e:
                 logger.error(f"Task {self.id}: Failed to process memory operations: {e}")
@@ -295,7 +297,7 @@ Expected Output: {self.expected_output}.
                         context_results.append(
                             f"Previous task {context_item.name if context_item.name else context_item.description} has no result yet."
                         )
-            
+
             # Join unique context results
             unique_contexts = list(dict.fromkeys(context_results))  # Remove duplicates
             task_prompt += f"""
@@ -307,7 +309,7 @@ Context:
     def execute_callback_sync(self, task_output: TaskOutput) -> None:
         """
         Synchronous wrapper to ensure that execute_callback is awaited,
-        preventing 'Task was destroyed but pending!' warnings if called 
+        preventing 'Task was destroyed but pending!' warnings if called
         from non-async code.
         """
         import asyncio

praisonaiagents/tools/train/data/generatecot.py

@@ -3,6 +3,16 @@ 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 +31,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"""
@@ -245,23 +263,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
 
@@ -332,29 +360,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 +422,37 @@ 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.58.dist-info → praisonaiagents-0.0.60.dist-info}/METADATA

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

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

@@ -9,12 +9,12 @@ 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=G2wKMwitWBJRS6nOq9W77zXtsxvJwsVwXFOKYcllY0E,51386
+praisonaiagents/llm/llm.py,sha256=t47T80kL2QEUSAGfNYHQG130d-CRUDxXi0AwStW0zkk,58156
 praisonaiagents/memory/memory.py,sha256=I8dOTkrl1i-GgQbDcrFOsSruzJ7MiI6Ys37DK27wrUs,35537
 praisonaiagents/process/__init__.py,sha256=lkYbL7Hn5a0ldvJtkdH23vfIIZLIcanK-65C0MwaorY,52
-praisonaiagents/process/process.py,sha256=BrS8_4Gt2ewXt559hThJTSrXVYG8daabO9tGDaWmrm0,44906
+praisonaiagents/process/process.py,sha256=HPw84OhnKQW3EyrDkpoQu0DcpxThbrzR2hWUgwQh9Pw,59955
 praisonaiagents/task/__init__.py,sha256=VL5hXVmyGjINb34AalxpBMl-YW9m5EDcRkMTKkSSl7c,80
-praisonaiagents/task/task.py,sha256=ikFjzNm4WPYONSLtWA3uDGNIUx_TvXTeU5SukWoC66E,14271
+praisonaiagents/task/task.py,sha256=8KztSUKMO74y619TyI8d5DMJ1xPbyQXIB0Ux583oOVw,14259
 praisonaiagents/tools/__init__.py,sha256=CWOYV9SudYY82r45LnNgaVRV3cmsAFdasNRkPrLsgmI,9198
 praisonaiagents/tools/arxiv_tools.py,sha256=1stb31zTjLTon4jCnpZG5de9rKc9QWgC0leLegvPXWo,10528
 praisonaiagents/tools/calculator_tools.py,sha256=S1xPT74Geurvjm52QMMIG29zDXVEWJmM6nmyY7yF298,9571
@@ -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=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,,
+praisonaiagents/tools/train/data/generatecot.py,sha256=EwrF6p-AWQQJktJeZu2O52ipbHGPd5y1IEmTLw-YSCs,19479
+praisonaiagents-0.0.60.dist-info/METADATA,sha256=I7mcUMdieRsRLzjdMO2Qkzt6dEY8Tm2X1XJIkydeIAg,830
+praisonaiagents-0.0.60.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+praisonaiagents-0.0.60.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
+praisonaiagents-0.0.60.dist-info/RECORD,,