PraisonAI 3.0.0__py3-none-any.whl

praisonai/inbuilt_tools/autogen_tools.py

@@ -0,0 +1,117 @@
+# praisonai/inbuilt_tools/autogen_tools.py
+
+import logging
+import inspect
+
+# Try to import praisonai_tools, but don't fail if not available
+try:
+    from praisonai_tools import (
+        CodeDocsSearchTool, CSVSearchTool, DirectorySearchTool, DOCXSearchTool,
+        DirectoryReadTool, FileReadTool, TXTSearchTool, JSONSearchTool,
+        MDXSearchTool, PDFSearchTool, RagTool, ScrapeElementFromWebsiteTool,
+        ScrapeWebsiteTool, WebsiteSearchTool, XMLSearchTool,
+        YoutubeChannelSearchTool, YoutubeVideoSearchTool
+    )
+    TOOLS_AVAILABLE = True
+except ImportError:
+    TOOLS_AVAILABLE = False
+
+def create_autogen_tool_function(tool_class):
+    """
+    Create a function that wraps a tool for autogen.
+    
+    Args:
+        tool_class: The tool class to wrap
+        
+    Returns:
+        function: A function that can be used with autogen agents
+    """
+    if not TOOLS_AVAILABLE:
+        return None
+        
+    def tool_function(assistant, user_proxy):
+        """
+        Wrapper function for the tool that works with autogen.
+        
+        Args:
+            assistant: The autogen assistant agent
+            user_proxy: The autogen user proxy agent
+        """
+        tool_instance = tool_class()
+        
+        # Get the tool's run method signature
+        sig = inspect.signature(tool_instance.run)
+        param_names = list(sig.parameters.keys())
+        
+        def wrapped_function(*args, **kwargs):
+            try:
+                # Map positional arguments to named parameters
+                named_args = dict(zip(param_names, args))
+                # Combine with keyword arguments
+                all_args = {**named_args, **kwargs}
+                # Run the tool
+                result = tool_instance.run(**all_args)
+                return str(result)
+            except Exception as e:
+                logging.error(f"Error running {tool_class.__name__}: {str(e)}")
+                return f"Error: {str(e)}"
+        
+        # Add the function to the assistant's function map
+        assistant.register_function(
+            function_map={
+                tool_class.__name__: wrapped_function
+            },
+            name_to_args={
+                tool_class.__name__: {
+                    param: "" for param in param_names
+                }
+            },
+            description=tool_instance.__doc__ or f"Use {tool_class.__name__} to perform operations"
+        )
+    
+    return tool_function if TOOLS_AVAILABLE else None
+
+# Only create tool functions if praisonai_tools is available
+if TOOLS_AVAILABLE:
+    # Create autogen wrapper functions for each tool
+    autogen_CSVSearchTool = create_autogen_tool_function(CSVSearchTool)
+    autogen_CodeDocsSearchTool = create_autogen_tool_function(CodeDocsSearchTool)
+    autogen_DirectorySearchTool = create_autogen_tool_function(DirectorySearchTool)
+    autogen_DOCXSearchTool = create_autogen_tool_function(DOCXSearchTool)
+    autogen_DirectoryReadTool = create_autogen_tool_function(DirectoryReadTool)
+    autogen_FileReadTool = create_autogen_tool_function(FileReadTool)
+    autogen_TXTSearchTool = create_autogen_tool_function(TXTSearchTool)
+    autogen_JSONSearchTool = create_autogen_tool_function(JSONSearchTool)
+    autogen_MDXSearchTool = create_autogen_tool_function(MDXSearchTool)
+    autogen_PDFSearchTool = create_autogen_tool_function(PDFSearchTool)
+    autogen_RagTool = create_autogen_tool_function(RagTool)
+    autogen_ScrapeElementFromWebsiteTool = create_autogen_tool_function(ScrapeElementFromWebsiteTool)
+    autogen_ScrapeWebsiteTool = create_autogen_tool_function(ScrapeWebsiteTool)
+    autogen_WebsiteSearchTool = create_autogen_tool_function(WebsiteSearchTool)
+    autogen_XMLSearchTool = create_autogen_tool_function(XMLSearchTool)
+    autogen_YoutubeChannelSearchTool = create_autogen_tool_function(YoutubeChannelSearchTool)
+    autogen_YoutubeVideoSearchTool = create_autogen_tool_function(YoutubeVideoSearchTool)
+
+    # Export all tool functions
+    __all__ = [
+        'autogen_CSVSearchTool',
+        'autogen_CodeDocsSearchTool',
+        'autogen_DirectorySearchTool',
+        'autogen_DOCXSearchTool',
+        'autogen_DirectoryReadTool',
+        'autogen_FileReadTool',
+        'autogen_TXTSearchTool',
+        'autogen_JSONSearchTool',
+        'autogen_MDXSearchTool',
+        'autogen_PDFSearchTool',
+        'autogen_RagTool',
+        'autogen_ScrapeElementFromWebsiteTool',
+        'autogen_ScrapeWebsiteTool',
+        'autogen_WebsiteSearchTool',
+        'autogen_XMLSearchTool',
+        'autogen_YoutubeChannelSearchTool',
+        'autogen_YoutubeVideoSearchTool',
+    ]
+else:
+    # If tools are not available, export an empty list
+    __all__ = []

praisonai/inc/__init__.py

@@ -0,0 +1,2 @@
+# praisonai/inc/__init__.py
+from .models import PraisonAIModel

praisonai/inc/config.py

@@ -0,0 +1,96 @@
+def generate_config(
+    ollama_save=None,
+    huggingface_save=None,
+    train=None,
+    model_name=None,
+    hf_model_name=None,
+    ollama_model_name=None,
+    model_parameters=None,
+    max_seq_length=None,
+    load_in_4bit=None,
+    lora_r=None,
+    lora_target_modules=None,
+    lora_alpha=None,
+    lora_dropout=None,
+    lora_bias=None,
+    use_gradient_checkpointing=None,
+    random_state=None,
+    use_rslora=None,
+    loftq_config=None,
+    dataset=None,
+    dataset_text_field=None,
+    dataset_num_proc=None,
+    packing=None,
+    per_device_train_batch_size=None,
+    gradient_accumulation_steps=None,
+    warmup_steps=None,
+    num_train_epochs=None,
+    max_steps=None,
+    learning_rate=None,
+    logging_steps=None,
+    optim=None,
+    weight_decay=None,
+    lr_scheduler_type=None,
+    seed=None,
+    output_dir=None,
+    quantization_method=None
+):
+    """Generates the configuration for PraisonAI with dynamic overrides."""
+
+    config = {
+        "ollama_save": ollama_save or "true",
+        "huggingface_save": huggingface_save or "true",
+        "train": train or "true",
+
+        "model_name": model_name or "unsloth/Meta-Llama-3.1-8B-Instruct-bnb-4bit",
+        "hf_model_name": hf_model_name or "mervinpraison/llama-3.1-tamilan-8B-test",
+        "ollama_model": ollama_model_name or "mervinpraison/llama3.1-tamilan-test",
+        "model_parameters": model_parameters or "8b",
+
+        "dataset": dataset or [
+            {
+                "name": "yahma/alpaca-cleaned",
+                "split_type": "train",
+                "processing_func": "format_prompts",
+                "rename": {"input": "input", "output": "output", "instruction": "instruction"},
+                "filter_data": False,
+                "filter_column_value": "id",
+                "filter_value": "alpaca",
+                "num_samples": 20000
+            }
+        ],
+
+        "dataset_text_field": dataset_text_field or "text",
+        "dataset_num_proc": dataset_num_proc or 2,
+        "packing": packing or False,
+
+        "max_seq_length": max_seq_length or 2048,
+        "load_in_4bit": load_in_4bit or True,
+        "lora_r": lora_r or 16,
+        "lora_target_modules": lora_target_modules or [
+            "q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"
+        ],
+        "lora_alpha": lora_alpha or 16,
+        "lora_dropout": lora_dropout or 0,
+        "lora_bias": lora_bias or "none",
+        "use_gradient_checkpointing": use_gradient_checkpointing or "unsloth",
+        "random_state": random_state or 3407,
+        "use_rslora": use_rslora or False,
+        "loftq_config": loftq_config or None,
+
+        "per_device_train_batch_size": per_device_train_batch_size or 2,
+        "gradient_accumulation_steps": gradient_accumulation_steps or 2,
+        "warmup_steps": warmup_steps or 5,
+        "num_train_epochs": num_train_epochs or 1,
+        "max_steps": max_steps or 10,
+        "learning_rate": learning_rate or 2.0e-4,
+        "logging_steps": logging_steps or 1,
+        "optim": optim or "adamw_8bit",
+        "weight_decay": weight_decay or 0.01,
+        "lr_scheduler_type": lr_scheduler_type or "linear",
+        "seed": seed or 3407,
+        "output_dir": output_dir or "outputs",
+
+        "quantization_method": quantization_method or ["q4_k_m"]
+    }
+    return config

praisonai/inc/models.py

@@ -0,0 +1,155 @@
+# praisonai/inc/models.py
+import os
+import logging
+from urllib.parse import urlparse
+logger = logging.getLogger(__name__)
+_loglevel = os.environ.get('LOGLEVEL', 'INFO').strip().upper() or 'INFO'
+logging.basicConfig(level=_loglevel, format='%(asctime)s - %(levelname)s - %(message)s')
+
+# Constants
+LOCAL_SERVER_API_KEY_PLACEHOLDER = "not-needed"
+
+# Conditionally import modules based on availability
+try:
+    from langchain_openai import ChatOpenAI  # pip install langchain-openai
+    OPENAI_AVAILABLE = True
+except ImportError:
+    OPENAI_AVAILABLE = False
+
+try:
+    from langchain_google_genai import ChatGoogleGenerativeAI  # pip install langchain-google-genai
+    GOOGLE_GENAI_AVAILABLE = True
+except ImportError:
+    GOOGLE_GENAI_AVAILABLE = False
+
+try:
+    from langchain_anthropic import ChatAnthropic  # pip install langchain-anthropic
+    ANTHROPIC_AVAILABLE = True
+except ImportError:
+    ANTHROPIC_AVAILABLE = False
+
+try:
+    from langchain_cohere import ChatCohere  # pip install langchain-cohere
+    COHERE_AVAILABLE = True
+except ImportError:
+    COHERE_AVAILABLE = False
+
+class PraisonAIModel:
+    def __init__(self, model=None, api_key_var=None, base_url=None, api_key=None):
+        """
+        Initializes the PraisonAIModel with the provided parameters or environment variables.
+
+        Args:
+            model (str, optional): The name of the OpenAI model. Defaults to None.
+            api_key_var (str, optional): The environment variable name for the API key. Defaults to None.
+            base_url (str, optional): The base URL for the OpenAI API. Defaults to None.
+            api_key (str, optional): The explicit API key to use. Takes precedence over environment variables. Defaults to None.
+        """
+        self.model =  model or os.getenv("OPENAI_MODEL_NAME", "gpt-5-nano")
+        if self.model.startswith("openai/"):
+            self.api_key_var = "OPENAI_API_KEY"
+            self.base_url = base_url or "https://api.openai.com/v1"
+            self.model_name = self.model.replace("openai/", "")
+        elif self.model.startswith("groq/"):
+            self.api_key_var = "GROQ_API_KEY"
+            self.base_url = base_url or "https://api.groq.com/openai/v1"
+            self.model_name = self.model.replace("groq/", "")
+        elif self.model.startswith("cohere/"):
+            self.api_key_var = "COHERE_API_KEY"
+            self.base_url = ""
+            self.model_name = self.model.replace("cohere/", "")
+        elif self.model.startswith("ollama/"):
+            self.api_key_var = "OLLAMA_API_KEY"
+            self.base_url = base_url or "http://localhost:11434/v1"
+            self.model_name = self.model.replace("ollama/", "")
+        elif self.model.startswith("anthropic/"):
+            self.api_key_var = "ANTHROPIC_API_KEY"
+            self.base_url = ""
+            self.model_name = self.model.replace("anthropic/", "")
+        elif self.model.startswith("google/"):
+            self.api_key_var = "GOOGLE_API_KEY"
+            self.base_url = ""
+            self.model_name = self.model.replace("google/", "")
+        elif self.model.startswith("openrouter/"):
+            self.api_key_var = "OPENROUTER_API_KEY"
+            self.base_url = base_url or "https://openrouter.ai/api/v1"
+            self.model_name = self.model.replace("openrouter/", "")
+        else: 
+            self.api_key_var = api_key_var or "OPENAI_API_KEY" 
+            self.base_url = base_url or os.environ.get("OPENAI_API_BASE") or os.environ.get("OPENAI_BASE_URL") or "https://api.openai.com/v1"
+            self.model_name = self.model
+        logger.debug(f"Initialized PraisonAIModel with model {self.model_name}, api_key_var {self.api_key_var}, and base_url {self.base_url}")
+
+        # Get API key from environment
+        self.api_key = api_key or os.environ.get(self.api_key_var)
+        
+        # For local servers, allow placeholder API key if base_url is set to non-OpenAI endpoint
+        if not self.api_key and self.base_url:
+            parsed_url = urlparse(self.base_url)
+            is_local = (parsed_url.hostname in ["localhost", "127.0.0.1"] or 
+                       "api.openai.com" not in self.base_url)
+            if is_local:
+                self.api_key = LOCAL_SERVER_API_KEY_PLACEHOLDER
+        
+        if not self.api_key:
+            raise ValueError(
+                f"{self.api_key_var} environment variable is required for the default OpenAI service. "
+                f"For local servers, set {self.api_key_var}='{LOCAL_SERVER_API_KEY_PLACEHOLDER}' and OPENAI_API_BASE to your local endpoint."
+            )
+
+
+    def get_model(self):
+        """
+        Returns an instance of the langchain Chat client with the configured parameters.
+
+        Returns:
+            Chat: An instance of the langchain Chat client.
+        """
+        if self.model.startswith("google/"):
+            if GOOGLE_GENAI_AVAILABLE:
+                return ChatGoogleGenerativeAI(
+                    model=self.model_name,
+                    google_api_key=self.api_key
+                )
+            else:
+                raise ImportError(
+                    "Required Langchain Integration 'langchain-google-genai' not found. "
+                    "Please install with 'pip install langchain-google-genai'"
+                )
+        elif self.model.startswith("cohere/"):
+            if COHERE_AVAILABLE:
+                return ChatCohere(
+                    model=self.model_name,
+                    cohere_api_key=self.api_key,
+                )
+            else:
+                raise ImportError(
+                    "Required Langchain Integration 'langchain-cohere' not found. "
+                    "Please install with 'pip install langchain-cohere'"
+                )
+        elif self.model.startswith("anthropic/"):
+            if ANTHROPIC_AVAILABLE:
+                return ChatAnthropic(
+                    model=self.model_name,
+                    anthropic_api_key=self.api_key,
+                )
+            else:
+                raise ImportError(
+                    "Required Langchain Integration 'langchain-anthropic' not found. "
+                    "Please install with 'pip install langchain-anthropic'"
+                )
+        elif OPENAI_AVAILABLE:
+            chat_kwargs = {
+                "model": self.model_name,
+                "api_key": self.api_key,
+                "base_url": self.base_url,
+            }
+            # Certain OpenAI models (e.g., gpt-5-* family) only allow temperature=1
+            if isinstance(self.model_name, str) and self.model_name.startswith("gpt-5"):
+                chat_kwargs["temperature"] = 1
+            return ChatOpenAI(**chat_kwargs)
+        else:
+            raise ImportError(
+                "Required Langchain Integration 'langchain-openai' not found. "
+                "Please install with 'pip install langchain-openai'"
+            )

praisonai/integrations/__init__.py

@@ -0,0 +1,56 @@
+"""
+PraisonAI Integrations - External CLI tool integrations.
+
+This module provides integrations with external AI coding CLI tools:
+- Claude Code CLI
+- Gemini CLI
+- OpenAI Codex CLI
+- Cursor CLI
+
+All integrations use lazy loading to avoid performance impact.
+
+Usage:
+    from praisonai.integrations import ClaudeCodeIntegration, GeminiCLIIntegration
+    
+    # Create integration
+    claude = ClaudeCodeIntegration(workspace="/path/to/project")
+    
+    # Use as agent tool
+    tool = claude.as_tool()
+    
+    # Or execute directly
+    result = await claude.execute("Refactor this code")
+"""
+
+# Lazy imports to avoid performance impact
+__all__ = [
+    'BaseCLIIntegration',
+    'ClaudeCodeIntegration',
+    'GeminiCLIIntegration',
+    'CodexCLIIntegration',
+    'CursorCLIIntegration',
+    'get_available_integrations',
+]
+
+
+def __getattr__(name):
+    """Lazy load integrations to minimize import overhead."""
+    if name == 'BaseCLIIntegration':
+        from .base import BaseCLIIntegration
+        return BaseCLIIntegration
+    elif name == 'ClaudeCodeIntegration':
+        from .claude_code import ClaudeCodeIntegration
+        return ClaudeCodeIntegration
+    elif name == 'GeminiCLIIntegration':
+        from .gemini_cli import GeminiCLIIntegration
+        return GeminiCLIIntegration
+    elif name == 'CodexCLIIntegration':
+        from .codex_cli import CodexCLIIntegration
+        return CodexCLIIntegration
+    elif name == 'CursorCLIIntegration':
+        from .cursor_cli import CursorCLIIntegration
+        return CursorCLIIntegration
+    elif name == 'get_available_integrations':
+        from .base import get_available_integrations
+        return get_available_integrations
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")