diagram-to-iac 0.6.0__py3-none-any.whl → 0.8.0__py3-none-any.whl

diagram_to_iac/tools/hello/__init__.py

@@ -0,0 +1,30 @@
+"""
+Hello LangGraph Agent Tools Package
+
+This package contains tools specific to the HelloAgent:
+- cal_utils: Arithmetic operations (addition, multiplication)
+- text_utils: Text processing utilities
+
+These tools have been moved from agents/hello_langgraph/tools/ to provide
+better organization and reusability across the codebase.
+"""
+
+# Import text utilities (no external dependencies)
+from .text_utils import extract_numbers_from_text, extract_numbers_from_text_with_duplicates
+
+# Import calculation utilities (requires langchain_core)
+try:
+    from .cal_utils import add_two, multiply_two
+    _cal_utils_available = True
+except ImportError:
+    _cal_utils_available = False
+    add_two = None
+    multiply_two = None
+
+__all__ = [
+    "extract_numbers_from_text", 
+    "extract_numbers_from_text_with_duplicates"
+]
+
+if _cal_utils_available:
+    __all__.extend(["add_two", "multiply_two"])

diagram_to_iac/tools/hello/cal_utils.py

@@ -0,0 +1,31 @@
+from langchain_core.tools import tool # Updated import for modern LangChain
+from pydantic import BaseModel, Field
+
+# --- Pydantic Schemas for Tool Inputs ---
+class AddToolInput(BaseModel):
+    x: int = Field(..., description="The first number for addition")
+    y: int = Field(..., description="The second number for addition")
+
+class MultiplyToolInput(BaseModel):
+    x: int = Field(..., description="The first number for multiplication")
+    y: int = Field(..., description="The second number for multiplication")
+
+# --- Tool Definitions ---
+@tool(args_schema=AddToolInput)
+def add_two(x: int, y: int) -> int:
+    """Add two numbers. Expects input according to AddToolInput schema."""
+    # The decorator @tool with args_schema handles parsing the input dict
+    # into AddToolInput and then passes the fields (x, y) to this function.
+    # So, the function signature remains simple (x: int, y: int).
+    # If we wanted the function to receive the Pydantic model itself,
+    # the tool definition and invocation would be slightly different, often
+    # by defining a custom Tool class or using StructuredTool.from_function
+    # where the function takes the Pydantic model.
+    # For @tool, it unpacks the validated args.
+    return x + y
+
+@tool(args_schema=MultiplyToolInput)
+def multiply_two(x: int, y: int) -> int:
+    """Multiply two numbers. Expects input according to MultiplyToolInput schema."""
+    # Similar to add_two, @tool unpacks the validated fields from MultiplyToolInput.
+    return x * y

diagram_to_iac/tools/hello/text_utils.py

@@ -0,0 +1,97 @@
+import re
+from typing import List
+
+def extract_numbers_from_text(text: str) -> List[int]:
+    """
+    Extract all integer numbers from a given text string, handling various formats.
+
+    This function finds sequences of digits and also extracts numbers from patterns
+    like "number operator number" (e.g., "4*5", "7 + 3"). It returns a list of unique
+    integers found, preserving the order of their first appearance in the text.
+
+    Args:
+        text: The input string from which to extract numbers.
+
+    Returns:
+        A list of unique integers found in the text, in order of appearance.
+        Returns an empty list if no numbers are found.
+
+    Supports:
+    - Space-separated numbers: "4 + 5", "add 7 and 3"
+    - Adjacent numbers with operators: "4*5", "6+2"
+    - Basic extraction of digit sequences.
+    """
+    numbers = []
+
+    # First, find all digit sequences using regex, avoiding phone number confusion
+    digit_matches = re.findall(r'\b\d+\b', text)
+    numbers.extend([int(match) for match in digit_matches])
+
+    # Handle cases where numbers are adjacent to operators like "4*5" or "7+3"
+    # Use specific operators (not dash) to avoid phone number confusion
+    operator_adjacent = re.findall(r'(\d+)\s*[+*/×÷%]\s*(\d+)', text)
+    for match in operator_adjacent:
+        numbers.extend([int(match[0]), int(match[1])])
+
+    # Handle negative numbers in explicit mathematical contexts
+    # Look for patterns like "What is -10 + 5?" but avoid phone numbers
+    math_negative = re.findall(r'(?:is|add|subtract|plus|minus|\+|\*|/)\s+(-\d+)', text, re.IGNORECASE)
+    for match in math_negative:
+        numbers.append(int(match))
+    
+    # Also catch negative numbers at the start of mathematical expressions
+    start_negative = re.findall(r'(?:^|\s)(-\d+)\s*[+*/×÷%]', text)
+    for match in start_negative:
+        numbers.append(int(match))
+
+    # Remove duplicates while preserving order of first appearance
+    seen = set()
+    unique_numbers = []
+    for num_val in numbers: # Renamed 'num' to 'num_val' to avoid conflict if 'num' was a global
+        if num_val not in seen:
+            unique_numbers.append(num_val)
+            seen.add(num_val)
+
+    return unique_numbers
+
+def extract_numbers_from_text_with_duplicates(text: str) -> List[int]:
+    """
+    Extract all integer numbers from a given text string, preserving duplicates.
+
+    This function is similar to extract_numbers_from_text but preserves duplicate
+    numbers, which is useful for operations like "10 * 10" where both numbers
+    are needed even if they're the same.
+
+    Args:
+        text: The input string from which to extract numbers.
+
+    Returns:
+        A list of integers found in the text, in order of appearance, including duplicates.
+        Returns an empty list if no numbers are found.
+
+    Examples:
+        >>> extract_numbers_from_text_with_duplicates("Calculate 10 * 10")
+        [10, 10]
+        >>> extract_numbers_from_text_with_duplicates("What is 5 + 7?")
+        [5, 7]
+    """
+    # Use a comprehensive regex to find all numbers (positive and negative) in one pass
+    # This regex matches:
+    # 1. Negative numbers in math contexts: "What is -10 + 5?"
+    # 2. Regular positive numbers: "10", "5", etc.
+    # 3. Avoids phone number dashes by being specific about negative contexts
+    
+    results = []
+    
+    # Combined pattern that captures both positive and negative numbers
+    # Negative numbers: preceded by math keywords or operators, followed by math operators
+    # Positive numbers: standalone digit sequences
+    pattern = r'(?:(?:is|add|subtract|plus|minus|\+|\*|/|^|\s)[-\s]*(-\d+)(?=\s*[+\-*/×÷%\s]|$))|(?:\b(\d+)\b)'
+    
+    for match in re.finditer(pattern, text, re.IGNORECASE):
+        if match.group(1):  # Negative number
+            results.append(int(match.group(1)))
+        elif match.group(2):  # Positive number
+            results.append(int(match.group(2)))
+    
+    return results

diagram_to_iac/tools/llm_utils/__init__.py

@@ -0,0 +1,20 @@
+"""
+LLM Utils Package
+
+Provides LLM routing, drivers, and utilities for the diagram-to-iac project.
+"""
+
+from .router import LLMRouter, get_llm
+from .base_driver import BaseLLMDriver
+from .openai_driver import OpenAIDriver
+from .anthropic_driver import AnthropicDriver
+from .gemini_driver import GoogleDriver
+
+__all__ = [
+    "LLMRouter",
+    "get_llm",
+    "BaseLLMDriver", 
+    "OpenAIDriver",
+    "AnthropicDriver",
+    "GoogleDriver"
+]

diagram_to_iac/tools/llm_utils/anthropic_driver.py

@@ -0,0 +1,87 @@
+"""
+Anthropic LLM Driver
+
+Provides Anthropic Claude-specific optimizations and features.
+"""
+
+import os
+from typing import Dict, Any, List
+from langchain_anthropic import ChatAnthropic
+from .base_driver import BaseLLMDriver
+
+
+class AnthropicDriver(BaseLLMDriver):
+    """Anthropic Claude-specific LLM driver."""
+    
+    SUPPORTED_MODELS = [
+        "claude-3-5-sonnet-20241022", "claude-3-5-haiku-20241022",
+        "claude-3-opus-20240229", "claude-3-sonnet-20240229", 
+        "claude-3-haiku-20240307"
+    ]
+    
+    MODEL_CAPABILITIES = {
+        "claude-3-5-sonnet-20241022": {"context_length": 200000, "function_calling": True, "vision": True},
+        "claude-3-5-haiku-20241022": {"context_length": 200000, "function_calling": True, "vision": True},
+        "claude-3-opus-20240229": {"context_length": 200000, "function_calling": True, "vision": True},
+        "claude-3-sonnet-20240229": {"context_length": 200000, "function_calling": True, "vision": True},
+        "claude-3-haiku-20240307": {"context_length": 200000, "function_calling": True, "vision": False},
+    }
+    
+    def validate_config(self, config: Dict[str, Any]) -> bool:
+        """Validate Anthropic-specific configuration."""
+        if not os.getenv("ANTHROPIC_API_KEY"):
+            raise ValueError("ANTHROPIC_API_KEY environment variable not set")
+        
+        model = config.get("model")
+        if model and model not in self.SUPPORTED_MODELS:
+            raise ValueError(f"Unsupported Anthropic model: {model}. Supported models: {self.SUPPORTED_MODELS}")
+        
+        # Validate temperature range
+        temperature = config.get("temperature")
+        if temperature is not None and (temperature < 0 or temperature > 1):
+            raise ValueError("Anthropic temperature must be between 0 and 1")
+        
+        return True
+    
+    def create_llm(self, config: Dict[str, Any]) -> ChatAnthropic:
+        """Create optimized Anthropic LLM instance."""
+        self.validate_config(config)
+        
+        # Anthropic-specific optimizations
+        llm_config = {
+            "model": config["model"],
+            "temperature": config.get("temperature", 0.0),
+            "max_tokens": config.get("max_tokens", 1024),
+            "top_p": config.get("top_p"),
+            "top_k": config.get("top_k"),  # Anthropic-specific parameter
+        }
+        
+        # Remove None values
+        llm_config = {k: v for k, v in llm_config.items() if v is not None}
+        
+        return ChatAnthropic(**llm_config)
+    
+    def get_supported_models(self) -> List[str]:
+        """Return list of supported Anthropic models."""
+        return self.SUPPORTED_MODELS.copy()
+    
+    def get_model_capabilities(self, model: str) -> Dict[str, Any]:
+        """Return capabilities for specific Anthropic model."""
+        return self.MODEL_CAPABILITIES.get(model, {})
+    
+    def estimate_cost(self, model: str, input_tokens: int, output_tokens: int) -> float:
+        """Estimate cost based on Anthropic pricing (as of 2024)."""
+        # Pricing per 1K tokens in USD
+        pricing = {
+            "claude-3-5-sonnet-20241022": {"input": 0.003, "output": 0.015},
+            "claude-3-5-haiku-20241022": {"input": 0.00025, "output": 0.00125},
+            "claude-3-opus-20240229": {"input": 0.015, "output": 0.075},
+            "claude-3-sonnet-20240229": {"input": 0.003, "output": 0.015},
+            "claude-3-haiku-20240307": {"input": 0.00025, "output": 0.00125},
+        }
+        
+        if model not in pricing:
+            return 0.0
+        
+        rates = pricing[model]
+        return (input_tokens / 1000 * rates["input"]) + (output_tokens / 1000 * rates["output"])

diagram_to_iac/tools/llm_utils/base_driver.py

@@ -0,0 +1,90 @@
+"""
+Base LLM Driver Interface
+
+This module provides the abstract base class for all LLM provider drivers.
+Each driver implements provider-specific optimizations and features.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any, List, Optional
+from langchain_core.language_models.chat_models import BaseChatModel
+
+
+class BaseLLMDriver(ABC):
+    """Abstract base class for all LLM provider drivers."""
+    
+    @abstractmethod
+    def validate_config(self, config: Dict[str, Any]) -> bool:
+        """
+        Validate provider-specific configuration.
+        
+        Args:
+            config: Configuration dictionary containing model parameters
+            
+        Returns:
+            bool: True if configuration is valid
+            
+        Raises:
+            ValueError: If configuration is invalid
+        """
+        pass
+    
+    @abstractmethod
+    def create_llm(self, config: Dict[str, Any]) -> BaseChatModel:
+        """
+        Create and configure LLM instance.
+        
+        Args:
+            config: Configuration dictionary containing model parameters
+            
+        Returns:
+            BaseChatModel: Configured LLM instance
+        """
+        pass
+    
+    @abstractmethod
+    def get_supported_models(self) -> List[str]:
+        """
+        Return list of supported models for this provider.
+        
+        Returns:
+            List[str]: List of supported model names
+        """
+        pass
+    
+    @abstractmethod
+    def get_model_capabilities(self, model: str) -> Dict[str, Any]:
+        """
+        Return capabilities for specific model.
+        
+        Args:
+            model: Model name
+            
+        Returns:
+            Dict containing capabilities like context_length, function_calling, vision, etc.
+        """
+        pass
+    
+    @abstractmethod
+    def estimate_cost(self, model: str, input_tokens: int, output_tokens: int) -> float:
+        """
+        Estimate cost for given token usage.
+        
+        Args:
+            model: Model name
+            input_tokens: Number of input tokens
+            output_tokens: Number of output tokens
+            
+        Returns:
+            float: Estimated cost in USD
+        """
+        pass
+    
+    def get_provider_name(self) -> str:
+        """
+        Get the provider name for this driver.
+        
+        Returns:
+            str: Provider name (e.g., 'openai', 'anthropic', 'google')
+        """
+        return self.__class__.__name__.lower().replace('driver', '')

diagram_to_iac/tools/llm_utils/gemini_driver.py

@@ -0,0 +1,89 @@
+"""
+Google Gemini LLM Driver
+
+Provides Google Gemini-specific optimizations and features.
+"""
+
+import os
+from typing import Dict, Any, List
+from langchain_google_genai import ChatGoogleGenerativeAI
+from .base_driver import BaseLLMDriver
+
+
+class GoogleDriver(BaseLLMDriver):
+    """Google Gemini-specific LLM driver."""
+    
+    SUPPORTED_MODELS = [
+        "gemini-1.5-pro", "gemini-1.5-flash", "gemini-1.5-flash-8b",
+        "gemini-1.0-pro", "gemini-pro", "gemini-pro-vision"
+    ]
+    
+    MODEL_CAPABILITIES = {
+        "gemini-1.5-pro": {"context_length": 1000000, "function_calling": True, "vision": True},
+        "gemini-1.5-flash": {"context_length": 1000000, "function_calling": True, "vision": True},
+        "gemini-1.5-flash-8b": {"context_length": 1000000, "function_calling": True, "vision": True},
+        "gemini-1.0-pro": {"context_length": 30720, "function_calling": True, "vision": False},
+        "gemini-pro": {"context_length": 30720, "function_calling": True, "vision": False},
+        "gemini-pro-vision": {"context_length": 12288, "function_calling": False, "vision": True},
+    }
+    
+    def validate_config(self, config: Dict[str, Any]) -> bool:
+        """Validate Google-specific configuration."""
+        if not os.getenv("GOOGLE_API_KEY"):
+            raise ValueError("GOOGLE_API_KEY environment variable not set")
+        
+        model = config.get("model")
+        if model and model not in self.SUPPORTED_MODELS:
+            raise ValueError(f"Unsupported Google model: {model}. Supported models: {self.SUPPORTED_MODELS}")
+        
+        # Validate temperature range
+        temperature = config.get("temperature")
+        if temperature is not None and (temperature < 0 or temperature > 1):
+            raise ValueError("Google temperature must be between 0 and 1")
+        
+        return True
+    
+    def create_llm(self, config: Dict[str, Any]) -> ChatGoogleGenerativeAI:
+        """Create optimized Google LLM instance."""
+        self.validate_config(config)
+        
+        # Google-specific optimizations
+        llm_config = {
+            "model": config["model"],
+            "temperature": config.get("temperature", 0.0),
+            "max_tokens": config.get("max_tokens"),
+            "top_p": config.get("top_p"),
+            "top_k": config.get("top_k"),  # Google-specific parameter
+            "google_api_key": os.getenv("GOOGLE_API_KEY"),
+        }
+        
+        # Remove None values (except google_api_key)
+        llm_config = {k: v for k, v in llm_config.items() if v is not None}
+        
+        return ChatGoogleGenerativeAI(**llm_config)
+    
+    def get_supported_models(self) -> List[str]:
+        """Return list of supported Google models."""
+        return self.SUPPORTED_MODELS.copy()
+    
+    def get_model_capabilities(self, model: str) -> Dict[str, Any]:
+        """Return capabilities for specific Google model."""
+        return self.MODEL_CAPABILITIES.get(model, {})
+    
+    def estimate_cost(self, model: str, input_tokens: int, output_tokens: int) -> float:
+        """Estimate cost based on Google pricing (as of 2024)."""
+        # Pricing per 1K tokens in USD
+        pricing = {
+            "gemini-1.5-pro": {"input": 0.00125, "output": 0.005},
+            "gemini-1.5-flash": {"input": 0.000075, "output": 0.0003},
+            "gemini-1.5-flash-8b": {"input": 0.0000375, "output": 0.00015},
+            "gemini-1.0-pro": {"input": 0.0005, "output": 0.0015},
+            "gemini-pro": {"input": 0.0005, "output": 0.0015},
+            "gemini-pro-vision": {"input": 0.00025, "output": 0.0005},
+        }
+        
+        if model not in pricing:
+            return 0.0
+        
+        rates = pricing[model]
+        return (input_tokens / 1000 * rates["input"]) + (output_tokens / 1000 * rates["output"])

diagram_to_iac/tools/llm_utils/openai_driver.py

@@ -0,0 +1,93 @@
+"""
+OpenAI LLM Driver
+
+Provides OpenAI-specific optimizations and features for ChatGPT models.
+"""
+
+import os
+from typing import Dict, Any, List
+from langchain_openai import ChatOpenAI
+from .base_driver import BaseLLMDriver
+
+
+class OpenAIDriver(BaseLLMDriver):
+    """OpenAI-specific LLM driver with advanced features."""
+    
+    SUPPORTED_MODELS = [
+        "gpt-4o", "gpt-4o-mini", "gpt-4-turbo", "gpt-4", 
+        "gpt-3.5-turbo", "gpt-3.5-turbo-16k"
+    ]
+    
+    MODEL_CAPABILITIES = {
+        "gpt-4o": {"context_length": 128000, "function_calling": True, "vision": True},
+        "gpt-4o-mini": {"context_length": 128000, "function_calling": True, "vision": True},
+        "gpt-4-turbo": {"context_length": 128000, "function_calling": True, "vision": True},
+        "gpt-4": {"context_length": 8192, "function_calling": True, "vision": False},
+        "gpt-3.5-turbo": {"context_length": 16385, "function_calling": True, "vision": False},
+        "gpt-3.5-turbo-16k": {"context_length": 16385, "function_calling": True, "vision": False},
+    }
+    
+    def validate_config(self, config: Dict[str, Any]) -> bool:
+        """Validate OpenAI-specific configuration."""
+        # In testing environments the OPENAI_API_KEY may not be set. Instead of
+        # raising an error immediately we log a warning and allow initialization
+        # to proceed so that the driver can be mocked.
+        if not os.getenv("OPENAI_API_KEY"):
+            print("Warning: OPENAI_API_KEY environment variable not set. Using placeholder key for testing.")
+            os.environ.setdefault("OPENAI_API_KEY", "test-key")
+        
+        model = config.get("model")
+        if model and model not in self.SUPPORTED_MODELS:
+            raise ValueError(f"Unsupported OpenAI model: {model}. Supported models: {self.SUPPORTED_MODELS}")
+        
+        # Validate temperature range
+        temperature = config.get("temperature")
+        if temperature is not None and (temperature < 0 or temperature > 2):
+            raise ValueError("OpenAI temperature must be between 0 and 2")
+        
+        return True
+    
+    def create_llm(self, config: Dict[str, Any]) -> ChatOpenAI:
+        """Create optimized OpenAI LLM instance."""
+        self.validate_config(config)
+        
+        # OpenAI-specific optimizations
+        llm_config = {
+            "model": config["model"],
+            "temperature": config.get("temperature", 0.0),
+            "max_tokens": config.get("max_tokens"),
+            "top_p": config.get("top_p"),
+            "frequency_penalty": config.get("frequency_penalty"),
+            "presence_penalty": config.get("presence_penalty"),
+        }
+        
+        # Remove None values
+        llm_config = {k: v for k, v in llm_config.items() if v is not None}
+        
+        return ChatOpenAI(**llm_config)
+    
+    def get_supported_models(self) -> List[str]:
+        """Return list of supported OpenAI models."""
+        return self.SUPPORTED_MODELS.copy()
+    
+    def get_model_capabilities(self, model: str) -> Dict[str, Any]:
+        """Return capabilities for specific OpenAI model."""
+        return self.MODEL_CAPABILITIES.get(model, {})
+    
+    def estimate_cost(self, model: str, input_tokens: int, output_tokens: int) -> float:
+        """Estimate cost based on OpenAI pricing (as of 2024)."""
+        # Pricing per 1K tokens in USD
+        pricing = {
+            "gpt-4o": {"input": 0.005, "output": 0.015},
+            "gpt-4o-mini": {"input": 0.000150, "output": 0.000600},
+            "gpt-4-turbo": {"input": 0.01, "output": 0.03},
+            "gpt-4": {"input": 0.03, "output": 0.06},
+            "gpt-3.5-turbo": {"input": 0.001, "output": 0.002},
+            "gpt-3.5-turbo-16k": {"input": 0.003, "output": 0.004},
+        }
+        
+        if model not in pricing:
+            return 0.0
+        
+        rates = pricing[model]
+        return (input_tokens / 1000 * rates["input"]) + (output_tokens / 1000 * rates["output"])