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

praisonaiagents/llm/llm.py

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

praisonaiagents/tools/train/data/generatecot.py

@@ -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.59.dist-info → praisonaiagents-0.0.60.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: praisonaiagents
-Version: 0.0.59
+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.59.dist-info → praisonaiagents-0.0.60.dist-info}/RECORD

@@ -9,7 +9,7 @@ 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=HPw84OhnKQW3EyrDkpoQu0DcpxThbrzR2hWUgwQh9Pw,59955
@@ -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.59.dist-info/METADATA,sha256=w6DYqKW5P9b2Rqu02j5Lt4-6K7f-InDrtUfV7fYu_FM,830
-praisonaiagents-0.0.59.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-praisonaiagents-0.0.59.dist-info/top_level.txt,sha256=_HsRddrJ23iDx5TTqVUVvXG2HeHBL5voshncAMDGjtA,16
-praisonaiagents-0.0.59.dist-info/RECORD,,
+praisonaiagents/tools/train/data/generatecot.py,sha256=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,,