quantalogic 0.33.4__py3-none-any.whl → 0.40.0__py3-none-any.whl

quantalogic/tools/{dalle_e.py → image_generation/dalle_e.py}

@@ -17,9 +17,11 @@ from quantalogic.tools.tool import Tool, ToolArgument
 
 class ImageProvider(str, Enum):
     """Supported image generation providers."""
+
     DALLE = "dall-e"
     STABLE_DIFFUSION = "stable-diffusion"
 
+
 PROVIDER_CONFIGS = {
     ImageProvider.DALLE: {
         "model_name": "dall-e-3",
@@ -28,14 +30,15 @@ PROVIDER_CONFIGS = {
         "styles": ["vivid", "natural"],
     },
     ImageProvider.STABLE_DIFFUSION: {
-        #"model_name": "anthropic.claude-3-sonnet-20240229",
+        # "model_name": "anthropic.claude-3-sonnet-20240229",
         "model_name": "amazon.titan-image-generator-v1",
         "sizes": ["1024x1024"],  # Bedrock SD supported size
         "qualities": ["standard"],  # SD quality is controlled by cfg_scale
-        "styles": ["none"],  # Style is controlled through prompting 
-    }
+        "styles": ["none"],  # Style is controlled through prompting
+    },
 }
 
+
 class LLMImageGenerationTool(Tool):
     """Tool for generating images using DALL-E or Stable Diffusion."""
 
@@ -118,23 +121,31 @@ class LLMImageGenerationTool(Tool):
         if self.generative_model is None:
             self.generative_model = GenerativeModel(model=self.model_name)
             logger.debug(f"Initialized LLMImageGenerationTool with model: {self.model_name}")
-        
+
         # Create output directory if it doesn't exist
         self.output_dir.mkdir(parents=True, exist_ok=True)
 
     def _validate_dalle_params(self, size: str, quality: str, style: str) -> None:
         """Validate DALL-E specific parameters."""
         if size not in PROVIDER_CONFIGS[ImageProvider.DALLE]["sizes"]:
-            raise ValueError(f"Invalid size for DALL-E. Must be one of: {PROVIDER_CONFIGS[ImageProvider.DALLE]['sizes']}")
+            raise ValueError(
+                f"Invalid size for DALL-E. Must be one of: {PROVIDER_CONFIGS[ImageProvider.DALLE]['sizes']}"
+            )
         if quality not in PROVIDER_CONFIGS[ImageProvider.DALLE]["qualities"]:
-            raise ValueError(f"Invalid quality for DALL-E. Must be one of: {PROVIDER_CONFIGS[ImageProvider.DALLE]['qualities']}")
+            raise ValueError(
+                f"Invalid quality for DALL-E. Must be one of: {PROVIDER_CONFIGS[ImageProvider.DALLE]['qualities']}"
+            )
         if style not in PROVIDER_CONFIGS[ImageProvider.DALLE]["styles"]:
-            raise ValueError(f"Invalid style for DALL-E. Must be one of: {PROVIDER_CONFIGS[ImageProvider.DALLE]['styles']}")
+            raise ValueError(
+                f"Invalid style for DALL-E. Must be one of: {PROVIDER_CONFIGS[ImageProvider.DALLE]['styles']}"
+            )
 
     def _validate_sd_params(self, size: str, cfg_scale: float) -> None:
         """Validate Stable Diffusion specific parameters."""
         if size not in PROVIDER_CONFIGS[ImageProvider.STABLE_DIFFUSION]["sizes"]:
-            raise ValueError(f"Invalid size for Stable Diffusion. Must be one of: {PROVIDER_CONFIGS[ImageProvider.STABLE_DIFFUSION]['sizes']}")
+            raise ValueError(
+                f"Invalid size for Stable Diffusion. Must be one of: {PROVIDER_CONFIGS[ImageProvider.STABLE_DIFFUSION]['sizes']}"
+            )
         if not 1.0 <= cfg_scale <= 20.0:
             raise ValueError("cfg_scale must be between 1.0 and 20.0")
 
@@ -144,12 +155,12 @@ class LLMImageGenerationTool(Tool):
         try:
             response = requests.get(image_url, timeout=30)
             response.raise_for_status()
-            
+
             file_path = self.output_dir / filename
             file_path.write_bytes(response.content)
             logger.info(f"Image saved successfully at: {file_path}")
             return file_path
-            
+
         except Exception as e:
             logger.error(f"Error saving image: {e}")
             raise
@@ -158,7 +169,7 @@ class LLMImageGenerationTool(Tool):
         """Save image metadata to JSON file."""
         try:
             metadata_path = self.output_dir / f"{metadata['filename']}.json"
-            with open(metadata_path, 'w') as f:
+            with open(metadata_path, "w") as f:
                 json.dump(metadata, f, indent=2)
             logger.info(f"Metadata saved successfully at: {metadata_path}")
         except Exception as e:
@@ -176,7 +187,7 @@ class LLMImageGenerationTool(Tool):
         cfg_scale: str = "7.5",
     ) -> str:
         """Execute the tool to generate an image based on the prompt.
-        
+
         Args:
             prompt: Text description of the image to generate
             provider: Provider to use (dall-e or stable-diffusion)
@@ -185,16 +196,18 @@ class LLMImageGenerationTool(Tool):
             style: Style preference for DALL-E
             negative_prompt: What to avoid in the image (Stable Diffusion only)
             cfg_scale: Classifier Free Guidance scale (Stable Diffusion only)
-            
+
         Returns:
             Path to the locally saved image
         """
         try:
             provider_enum = ImageProvider(provider.lower())
-            
+
             # Convert cfg_scale to float only if it's not empty and we're using Stable Diffusion
-            cfg_scale_float = float(cfg_scale) if cfg_scale and provider_enum == ImageProvider.STABLE_DIFFUSION else None
-            
+            cfg_scale_float = (
+                float(cfg_scale) if cfg_scale and provider_enum == ImageProvider.STABLE_DIFFUSION else None
+            )
+
             # Validate parameters based on provider
             if provider_enum == ImageProvider.DALLE:
                 self._validate_dalle_params(size, quality, style)
@@ -203,7 +216,7 @@ class LLMImageGenerationTool(Tool):
                     "size": size,
                     "quality": quality,
                     "style": style,
-                    "response_format": "url"
+                    "response_format": "url",
                 }
             else:  # Stable Diffusion
                 if cfg_scale_float is None:
@@ -214,29 +227,26 @@ class LLMImageGenerationTool(Tool):
                     "negative_prompt": negative_prompt,
                     "cfg_scale": cfg_scale_float,
                     "size": size,
-                    "response_format": "url"
+                    "response_format": "url",
                 }
 
             # Generate image
             logger.info(f"Generating image with {provider} using params: {params}")
-            response = self.generative_model.generate_image(
-                prompt=prompt,
-                params=params
-            )
+            response = self.generative_model.generate_image(prompt=prompt, params=params)
 
             # Extract image data from response
             if not response.data:
                 raise ValueError("No image data in response")
-            
+
             image_data = response.data[0]  # First image from the response
             image_url = str(image_data.get("url", ""))
             revised_prompt = str(image_data.get("revised_prompt", prompt))
-            
+
             if not image_url:
                 raise ValueError("No image URL in response")
 
             # Save image locally
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
             filename = f"{provider}_{timestamp}.png"
             local_path = self._save_image(image_url, filename)
 
@@ -250,12 +260,12 @@ class LLMImageGenerationTool(Tool):
                 "created": str(response.created or ""),
                 "parameters": {k: str(v) for k, v in {**params, "prompt": prompt}.items()},
                 "image_url": str(image_url),
-                "local_path": str(local_path)
+                "local_path": str(local_path),
             }
             self._save_metadata(metadata)
 
             logger.info(f"Image generated and saved at: {local_path}")
-            return str(local_path)
+            return str(metadata)
 
         except Exception as e:
             logger.error(f"Error generating image with {provider}: {e}")

quantalogic/tools/jinja_tool.py

@@ -14,7 +14,7 @@ class JinjaTool(Tool):
 
     name: str = "jinja_tool"
     description: str = (
-        "Renders an inline Jinja2 template string with a predefined context.\n" 
+        "Renders an inline Jinja2 template string with a predefined context.\n"
         "You can use the variables in the template just as var1, var2, etc.\n"
         "Useful for simple calculations or string operations.\n"
     )
@@ -41,7 +41,7 @@ class JinjaTool(Tool):
         """
         super().__init__()
 
-    def execute(self, inline_template: str,variables: Optional[Dict[str, Any]] = None) -> str:
+    def execute(self, inline_template: str, variables: Optional[Dict[str, Any]] = None) -> str:
         """
         Render an inline Jinja2 template with the predefined context.
 
@@ -72,20 +72,16 @@ class JinjaTool(Tool):
 
 if __name__ == "__main__":
     # Example of using JinjaTool with variables
-    tool = JinjaTool(context={
-        "var1": "World", 
-        "var2": 42, 
-        "var3": ["apple", "banana", "cherry"]
-    })
-    
+    tool = JinjaTool(context={"var1": "World", "var2": 42, "var3": ["apple", "banana", "cherry"]})
+
     # Inline template demonstrating variable usage
     template = "Hello {{ var1 }}! The answer is {{ var2 }}. Fruits: {% for fruit in var3 %}{{ fruit }}{% if not loop.last %}, {% endif %}{% endfor %}."
-    
+
     # Render the template
     result = tool.execute(template)
     print("Rendered Template:")
     print(result)
-    
+
     # Print the tool's markdown representation
     print("\nTool Markdown:")
     print(tool.to_markdown())

quantalogic/tools/language_handlers/__init__.py

@@ -1,12 +1,4 @@
-from .c_handler import CLanguageHandler
-from .cpp_handler import CppLanguageHandler
-from .go_handler import GoLanguageHandler
-from .java_handler import JavaLanguageHandler
-from .javascript_handler import JavaScriptLanguageHandler
-from .python_handler import PythonLanguageHandler
-from .rust_handler import RustLanguageHandler
-from .scala_handler import ScalaLanguageHandler
-from .typescript_handler import TypeScriptLanguageHandler
+import importlib
 
 __all__ = [
     "CLanguageHandler",
@@ -19,3 +11,24 @@ __all__ = [
     "ScalaLanguageHandler",
     "TypeScriptLanguageHandler",
 ]
+
+def __getattr__(name):
+    """Lazily import language handlers when they are first requested."""
+    if name in __all__:
+        module_map = {
+            "CLanguageHandler": "c_handler",
+            "CppLanguageHandler": "cpp_handler",
+            "GoLanguageHandler": "go_handler",
+            "JavaLanguageHandler": "java_handler",
+            "JavaScriptLanguageHandler": "javascript_handler",
+            "PythonLanguageHandler": "python_handler",
+            "RustLanguageHandler": "rust_handler",
+            "ScalaLanguageHandler": "scala_handler",
+            "TypeScriptLanguageHandler": "typescript_handler",
+        }
+        
+        module_name = module_map[name]
+        module = importlib.import_module(f".{module_name}", package=__package__)
+        return getattr(module, name)
+    
+    raise AttributeError(f"module '{__name__}' has no attribute '{name}'")

quantalogic/tools/list_directory_tool.py

@@ -1,9 +1,11 @@
 """Tool for listing the contents of a directory."""
 
 import os
+from pathlib import Path
+from typing import List, Dict
+from loguru import logger
 
 from quantalogic.tools.tool import Tool, ToolArgument
-from quantalogic.utils.git_ls import git_ls
 
 
 class ListDirectoryTool(Tool):
@@ -32,8 +34,8 @@ class ListDirectoryTool(Tool):
             arg_type="int",
             description="Maximum directory traversal depth",
             required=False,
-            default="1",
-            example="1",
+            default="10",
+            example="10",
         ),
         ToolArgument(
             name="start_line",
@@ -53,16 +55,95 @@ class ListDirectoryTool(Tool):
         ),
     ]
 
+    def _list_directory(self, path: Path, max_depth: int, current_depth: int = 0) -> List[Dict]:
+        """List directory contents recursively.
+        
+        Args:
+            path: Directory path to list
+            max_depth: Maximum recursion depth
+            current_depth: Current recursion depth
+            
+        Returns:
+            List of dictionaries containing file/directory information
+        """
+        if current_depth > max_depth:
+            return []
+
+        results = []
+        try:
+            for item in sorted(path.iterdir(), key=lambda x: (not x.is_dir(), x.name.lower())):
+                if item.name == ".git":
+                    continue
+                    
+                try:
+                    if item.is_file():
+                        size = item.stat().st_size
+                        results.append({
+                            "type": "file",
+                            "name": item.name,
+                            "size": f"{size} bytes",
+                            "path": str(item.relative_to(path.parent))
+                        })
+                    elif item.is_dir():
+                        children = self._list_directory(item, max_depth, current_depth + 1)
+                        results.append({
+                            "type": "directory",
+                            "name": item.name,
+                            "children": children,
+                            "path": str(item.relative_to(path.parent))
+                        })
+                except PermissionError:
+                    results.append({
+                        "type": "error",
+                        "name": item.name,
+                        "error": "Permission denied"
+                    })
+                except Exception as e:
+                    logger.error(f"Error processing {item}: {str(e)}")
+                    
+        except PermissionError:
+            return [{"type": "error", "name": path.name, "error": "Permission denied"}]
+        except Exception as e:
+            logger.error(f"Error listing directory {path}: {str(e)}")
+            return [{"type": "error", "name": path.name, "error": str(e)}]
+            
+        return results
+
+    def _format_tree(self, items: List[Dict], depth: int = 0) -> List[str]:
+        """Format directory tree into lines of text.
+        
+        Args:
+            items: List of file/directory items
+            depth: Current indentation depth
+            
+        Returns:
+            List of formatted lines
+        """
+        lines = []
+        indent = "  " * depth
+        
+        for item in items:
+            if item["type"] == "file":
+                lines.append(f"{indent} {item['path']} ({item['size']})")
+            elif item["type"] == "directory":
+                lines.append(f"{indent} {item['path']}/")
+                if "children" in item:
+                    lines.extend(self._format_tree(item["children"], depth + 1))
+            elif item["type"] == "error":
+                lines.append(f"{indent} {item['name']} ({item['error']})")
+                
+        return lines
+
     def execute(
         self,
         directory_path: str,
         recursive: str = "false",
-        max_depth: str = "1",
+        max_depth: str = "10",
         start_line: str = "1",
         end_line: str = "200",
     ) -> str:
         """
-        List directory contents with pagination and .gitignore support.
+        List directory contents with pagination.
 
         Args:
             directory_path: Absolute or relative path to target directory
@@ -77,47 +158,55 @@ class ListDirectoryTool(Tool):
         Raises:
             ValueError: For invalid directory paths or pagination parameters
         """
-        # Expand user home directory to full path
-        # This ensures compatibility with '~' shorthand for home directory
-        if directory_path.startswith("~"):
-            directory_path = os.path.expanduser(directory_path)
-
-        # Validate directory existence and type
-        # Fail early with clear error messages if path is invalid
-        if not os.path.exists(directory_path):
-            raise ValueError(f"The directory '{directory_path}' does not exist.")
-        if not os.path.isdir(directory_path):
-            raise ValueError(f"The path '{directory_path}' is not a directory.")
-
-        # Safely convert inputs with default values
-        start = int(start_line or "1")
-        end = int(end_line or "200")
-        max_depth_int = int(max_depth or "1")
-        is_recursive = (recursive or "false").lower() == "true"
-
-        # Validate pagination parameters
-        if start > end:
-            raise ValueError("start_line must be less than or equal to end_line.")
-
         try:
-            # Use git_ls for directory listing with .gitignore support
-            all_lines = git_ls(
-                directory_path=directory_path,
-                recursive=is_recursive,
-                max_depth=max_depth_int,
-                start_line=start,
-                end_line=end,
+            # Expand user home directory
+            if directory_path.startswith("~"):
+                directory_path = os.path.expanduser(directory_path)
+
+            path = Path(directory_path)
+            
+            # Validate directory
+            if not path.exists():
+                raise ValueError(f"The directory '{directory_path}' does not exist.")
+            if not path.is_dir():
+                raise ValueError(f"The path '{directory_path}' is not a directory.")
+
+            # Parse parameters
+            start = int(start_line)
+            end = int(end_line)
+            max_depth_int = int(max_depth)
+            is_recursive = recursive.lower() == "true"
+
+            if start > end:
+                raise ValueError("start_line must be less than or equal to end_line.")
+
+            # List directory contents
+            items = self._list_directory(
+                path=path,
+                max_depth=max_depth_int if is_recursive else 0
             )
-            return all_lines
+            
+            # Format output
+            lines = self._format_tree(items)
+            
+            if not lines:
+                return "==== No files to display ===="
+                
+            # Paginate results
+            total_lines = len(lines)
+            paginated_lines = lines[start - 1:end]
+            
+            header = f"==== Lines {start}-{min(end, total_lines)} of {total_lines} ===="
+            if end >= total_lines:
+                header += " [LAST BLOCK]"
+                
+            return f"{header}\n" + "\n".join(paginated_lines) + "\n==== End of Block ===="
+            
         except Exception as e:
-            import traceback
-
-            traceback.print_exc()
-            return f"Error: {str(e)} occurred during directory listing. See logs for details."
+            logger.error(f"Error listing directory: {str(e)}")
+            return f"Error: {str(e)}"
 
 
 if __name__ == "__main__":
     tool = ListDirectoryTool()
-    current_directory = os.getcwd()
-    tool.execute(directory_path=current_directory, recursive="true")
-    print(tool.to_markdown())
+    print(tool.execute(directory_path=".", recursive="true"))

quantalogic/tools/llm_tool.py

@@ -1,11 +1,13 @@
 """LLM Tool for generating answers to questions using a language model."""
 
+import asyncio
 from typing import Callable
 
 from loguru import logger
 from pydantic import ConfigDict, Field
 
 from quantalogic.console_print_token import console_print_token
+from quantalogic.event_emitter import EventEmitter
 from quantalogic.generative_model import GenerativeModel, Message
 from quantalogic.tools.tool import Tool, ToolArgument
 
@@ -58,6 +60,7 @@ class LLMTool(Tool):
     system_prompt: str | None = Field(default=None)
     on_token: Callable | None = Field(default=None, exclude=True)
     generative_model: GenerativeModel | None = Field(default=None, exclude=True)
+    event_emitter: EventEmitter | None = Field(default=None, exclude=True)
 
     def __init__(
         self,
@@ -66,7 +69,17 @@ class LLMTool(Tool):
         on_token: Callable | None = None,
         name: str = "llm_tool",
         generative_model: GenerativeModel | None = None,
+        event_emitter: EventEmitter | None = None,
     ):
+        """Initialize the LLMTool with model configuration and optional callback.
+
+        Args:
+            model_name (str): The name of the language model to use.
+            system_prompt (str, optional): Default system prompt for the model.
+            on_token (Callable, optional): Callback function for streaming tokens.
+            name (str): Name of the tool instance. Defaults to "llm_tool".
+            generative_model (GenerativeModel, optional): Pre-initialized generative model.
+        """
         # Use dict to pass validated data to parent constructor
         super().__init__(
             **{
@@ -75,16 +88,20 @@ class LLMTool(Tool):
                 "on_token": on_token,
                 "name": name,
                 "generative_model": generative_model,
+                "event_emitter": event_emitter,
             }
         )
-
+        
         # Initialize the generative model
         self.model_post_init(None)
 
     def model_post_init(self, __context):
         """Initialize the generative model after model initialization."""
         if self.generative_model is None:
-            self.generative_model = GenerativeModel(model=self.model_name)
+            self.generative_model = GenerativeModel(
+                model=self.model_name,
+                event_emitter=self.event_emitter
+            )
             logger.debug(f"Initialized LLMTool with model: {self.model_name}")
 
         # Only set up event listener if on_token is provided
@@ -92,14 +109,17 @@ class LLMTool(Tool):
             logger.debug(f"Setting up event listener for LLMTool with model: {self.model_name}")
             self.generative_model.event_emitter.on("stream_chunk", self.on_token)
 
-    def execute(
+    async def async_execute(
         self, system_prompt: str | None = None, prompt: str | None = None, temperature: str | None = None
     ) -> str:
-        """Execute the tool to generate an answer based on the provided question.
+        """Execute the tool to generate an answer asynchronously.
+
+        This method provides a native asynchronous implementation, utilizing the generative model's
+        asynchronous capabilities for improved performance in async contexts.
 
         Args:
-            system_prompt (str): The system prompt to guide the model.
-            prompt (str): The question to be answered.
+            system_prompt (str, optional): The system prompt to guide the model.
+            prompt (str, optional): The question to be answered.
             temperature (str, optional): Sampling temperature. Defaults to "0.7".
 
         Returns:
@@ -130,24 +150,25 @@ class LLMTool(Tool):
         if self.generative_model:
             self.generative_model.temperature = temp
 
-            # Generate the response using the generative model
+            # Generate the response asynchronously using the generative model
             try:
-                result = self.generative_model.generate_with_history(
+                result = await self.generative_model.async_generate_with_history(
                     messages_history=messages_history, prompt=prompt, streaming=is_streaming
                 )
 
                 if is_streaming:
                     response = ""
-                    for chunk in result:
+                    async for chunk in result:
                         response += chunk
+                        # Note: on_token is handled via the event emitter set in model_post_init
                 else:
                     response = result.response
 
-                logger.debug(f"Generated response: {response}")
+                logger.debug(f"Generated async response: {response}")
                 return response
             except Exception as e:
-                logger.error(f"Error generating response: {e}")
-                raise Exception(f"Error generating response: {e}") from e
+                logger.error(f"Error generating async response: {e}")
+                raise Exception(f"Error generating async response: {e}") from e
         else:
             raise ValueError("Generative model not initialized")
 
@@ -158,16 +179,25 @@ if __name__ == "__main__":
     system_prompt = 'Answer the question as truthfully as possible using the provided context, and if the answer is not contained within the context, say "I don\'t know".'
     question = "What is the meaning of life?"
     temperature = "0.7"
+
+    # Synchronous execution
     answer = tool.execute(system_prompt=system_prompt, prompt=question, temperature=temperature)
+    print("Synchronous Answer:")
     print(answer)
+
+    # Asynchronous execution with streaming
     pirate = LLMTool(
         model_name="openrouter/openai/gpt-4o-mini", system_prompt="You are a pirate.", on_token=console_print_token
     )
-    pirate_answer = pirate.execute(system_prompt=system_prompt, prompt=question, temperature=temperature)
-    print("\n")
-    print(f"Anwser: {pirate_answer}")
+    pirate_answer = asyncio.run(
+        pirate.async_execute(system_prompt=system_prompt, prompt=question, temperature=temperature)
+    )
+    print("\nAsynchronous Pirate Answer:")
+    print(f"Answer: {pirate_answer}")
 
+    # Display tool configuration in Markdown
     custom_tool = LLMTool(
         model_name="openrouter/openai/gpt-4o-mini", system_prompt="You are a pirate.", on_token=console_print_token
     )
+    print("\nTool Configuration:")
     print(custom_tool.to_markdown())