quantalogic 0.50.12__py3-none-any.whl → 0.50.18__py3-none-any.whl

quantalogic/tools/__init__.py

@@ -1,110 +1,70 @@
 """Tools for the QuantaLogic agent."""
 
-import importlib
-import sys
-from typing import Any, Dict
+from loguru import logger
 
+# Direct imports of tools
+from .agent_tool import AgentTool
+from .download_http_file_tool import DownloadHttpFileTool
+from .duckduckgo_search_tool import DuckDuckGoSearchTool
+from .edit_whole_content_tool import EditWholeContentTool
+from .elixir_tool import ElixirTool
+from .execute_bash_command_tool import ExecuteBashCommandTool
+from .grep_app_tool import GrepAppTool
+from .input_question_tool import InputQuestionTool
+from .jinja_tool import JinjaTool
+from .list_directory_tool import ListDirectoryTool
+from .llm_tool import LLMTool
+from .llm_vision_tool import LLMVisionTool
+from .markitdown_tool import MarkitdownTool
+from .nodejs_tool import NodeJsTool
+from .python_tool import PythonTool
+from .read_file_block_tool import ReadFileBlockTool
+from .read_file_tool import ReadFileTool
+from .read_html_tool import ReadHTMLTool
+from .replace_in_file_tool import ReplaceInFileTool
+from .ripgrep_tool import RipgrepTool
+from .safe_python_interpreter_tool import SafePythonInterpreterTool
+from .search_definition_names import SearchDefinitionNames
+from .sequence_tool import SequenceTool
+from .serpapi_search_tool import SerpApiSearchTool
+from .sql_query_tool import SQLQueryTool
+from .task_complete_tool import TaskCompleteTool
+from .tool import Tool, ToolArgument
+from .unified_diff_tool import UnifiedDiffTool
+from .wikipedia_search_tool import WikipediaSearchTool
+from .write_file_tool import WriteFileTool
 
-class LazyLoader:
-    """
-    Lazily import a module only when its attributes are accessed.
-    This helps reduce startup time by deferring imports until needed.
-    """
-    def __init__(self, module_path: str, optional: bool = False):
-        self.module_path = module_path
-        self._module = None
-        self.optional = optional
-
-    def __getattr__(self, name: str) -> Any:
-        if self._module is None:
-            try:
-                self._module = importlib.import_module(self.module_path)
-            except ImportError as e:
-                if self.optional:
-                    # If the tool is optional, log a warning but don't raise an error
-                    print(f"Warning: Optional tool {self.module_path} could not be imported: {e}")
-                    return None
-                raise
-
-        return getattr(self._module, name)
-
-
-# Map of tool names to their import paths and optional status
-_TOOL_IMPORTS = {
-    "AgentTool": (".agent_tool", False),
-    "ComposioTool": (".composio.composio", True),
-    "GenerateDatabaseReportTool": (".database.generate_database_report_tool", True),
-    "SQLQueryToolAdvanced": (".database.sql_query_tool_advanced", True),
-    "MarkdownToDocxTool": (".document_tools.markdown_to_docx_tool", True),
-    "MarkdownToEpubTool": (".document_tools.markdown_to_epub_tool", True),
-    "MarkdownToHtmlTool": (".document_tools.markdown_to_html_tool", True),
-    "MarkdownToIpynbTool": (".document_tools.markdown_to_ipynb_tool", True),
-    "MarkdownToLatexTool": (".document_tools.markdown_to_latex_tool", True),
-    "MarkdownToPdfTool": (".document_tools.markdown_to_pdf_tool", True),
-    "MarkdownToPptxTool": (".document_tools.markdown_to_pptx_tool", True),
-    "DownloadHttpFileTool": (".download_http_file_tool", False),
-    "DuckDuckGoSearchTool": (".duckduckgo_search_tool", False),
-    "EditWholeContentTool": (".edit_whole_content_tool", False),
-    "ElixirTool": (".elixir_tool", False),
-    "ExecuteBashCommandTool": (".execute_bash_command_tool", False),
-    "BitbucketCloneTool": (".git.bitbucket_clone_repo_tool", False),
-    "BitbucketOperationsTool": (".git.bitbucket_operations_tool", False),
-    "CloneRepoTool": (".git.clone_repo_tool", False),
-    "GitOperationsTool": (".git.git_operations_tool", False),
-    "GoogleNewsTool": (".google_packages.google_news_tool", False),
-    "GrepAppTool": (".grep_app_tool", False),
-    "LLMImageGenerationTool": (".image_generation.dalle_e", False),
-    "InputQuestionTool": (".input_question_tool", False),
-    "JinjaTool": (".jinja_tool", False),
-    "ListDirectoryTool": (".list_directory_tool", False),
-    "LLMTool": (".llm_tool", False),
-    "LLMVisionTool": (".llm_vision_tool", False),
-    "MarkitdownTool": (".markitdown_tool", False),
-    "NasaApodTool": (".nasa_packages.nasa_apod_tool", False),
-    "NasaNeoWsTool": (".nasa_packages.nasa_neows_tool", False),
-    "NodeJsTool": (".nodejs_tool", False),
-    "PresentationLLMTool": (".presentation_tools.presentation_llm_tool", False),
-    "ProductHuntTool": (".product_hunt.product_hunt_tool", False),
-    "PythonTool": (".python_tool", False),
-    "RagTool": (".rag_tool.rag_tool", False),
-    "ReadFileBlockTool": (".read_file_block_tool", False),
-    "ReadFileTool": (".read_file_tool", False),
-    "ReadHTMLTool": (".read_html_tool", False),
-    "ReplaceInFileTool": (".replace_in_file_tool", False),
-    "RipgrepTool": (".ripgrep_tool", False),
-    "SafePythonInterpreterTool": (".safe_python_interpreter_tool", False),
-    "SearchDefinitionNames": (".search_definition_names", False),
-    "SequenceTool": (".sequence_tool", False),
-    "SerpApiSearchTool": (".serpapi_search_tool", False),
-    "SQLQueryTool": (".sql_query_tool", True),
-    "TaskCompleteTool": (".task_complete_tool", False),
-    "Tool": (".tool", False),
-    "ToolArgument": (".tool", False),
-    "UnifiedDiffTool": (".unified_diff_tool", False),
-    "CSVProcessorTool": (".utilities.csv_processor_tool", False),
-    "PrepareDownloadTool": (".utilities.download_file_tool", False),
-    "MermaidValidatorTool": (".utilities.mermaid_validator_tool", False),
-    "WikipediaSearchTool": (".wikipedia_search_tool", False),
-    "WriteFileTool": (".write_file_tool", False),
-}
-
-# Create lazy loaders for each module path
-_lazy_modules: Dict[str, LazyLoader] = {}
-for tool, (path, optional) in _TOOL_IMPORTS.items():
-    full_path = f"{__package__}{path}"
-    if full_path not in _lazy_modules:
-        _lazy_modules[full_path] = LazyLoader(full_path, optional)
-
-# Set up attributes for lazy loading
-_tools_to_lazy_modules = {}
-for tool, (path, optional) in _TOOL_IMPORTS.items():
-    full_path = f"{__package__}{path}"
-    _tools_to_lazy_modules[tool] = _lazy_modules[full_path]
-
-# Define __all__ so that import * works properly
-__all__ = list(_TOOL_IMPORTS.keys())
-
-# Set up lazy loading for each tool
-for tool, lazy_module in _tools_to_lazy_modules.items():
-    # This will create properties that lazily load the requested tool
-    setattr(sys.modules[__name__], tool, getattr(lazy_module, tool))
+# Define __all__ to control what gets imported with `from quantalogic.tools import *`
+__all__ = [
+    'AgentTool',
+    'DownloadHttpFileTool',
+    'DuckDuckGoSearchTool',
+    'EditWholeContentTool',
+    'ElixirTool',
+    'ExecuteBashCommandTool',
+    'GrepAppTool',
+    'InputQuestionTool',
+    'JinjaTool',
+    'ListDirectoryTool',
+    'LLMTool',
+    'LLMVisionTool',
+    'MarkitdownTool',
+    'NodeJsTool',
+    'PythonTool',
+    'ReadFileBlockTool',
+    'ReadFileTool',
+    'ReadHTMLTool',
+    'ReplaceInFileTool',
+    'RipgrepTool',
+    'SafePythonInterpreterTool',
+    'SearchDefinitionNames',
+    'SequenceTool',
+    'SerpApiSearchTool',
+    'SQLQueryTool',
+    'TaskCompleteTool',
+    'Tool',
+    'ToolArgument',
+    'UnifiedDiffTool',
+    'WikipediaSearchTool',
+    'WriteFileTool'
+]

quantalogic/tools/composio/__init__.py

@@ -0,0 +1,18 @@
+"""
+Composio Tools Module
+
+This module provides tools and utilities from the Composio integration.
+"""
+
+from loguru import logger
+
+# Explicit imports of all tools in the module
+from .composio import ComposioTool
+
+# Define __all__ to control what is imported with `from ... import *`
+__all__ = [
+    'ComposioTool',
+]
+
+# Optional: Add logging for import confirmation
+logger.info("Composio tools module initialized successfully.")

quantalogic/tools/composio/composio.py

@@ -1,32 +1,17 @@
 """Tool for interacting with Composio API services."""
 
-import importlib
-import importlib.util
 import json
 import os
 import traceback
 from datetime import datetime
-from typing import Any, Dict, Optional, Union, TYPE_CHECKING
-
-# Type checking imports - these are only used for type hints and not at runtime
-if TYPE_CHECKING:
-    from composio import ComposioToolSet
+from typing import Any, Dict, Optional
 
+from composio import Action, ComposioToolSet
 from loguru import logger
 from pydantic import BaseModel, ConfigDict, Field
 
 from quantalogic.tools.tool import Tool, ToolArgument
 
-# Flag to check if composio is available
-COMPOSIO_AVAILABLE = False
-
-# Try to check if composio is importable without actually importing it
-try:
-    spec = importlib.util.find_spec("composio")
-    COMPOSIO_AVAILABLE = spec is not None
-except ImportError:
-    pass
-
 
 def setup_logger():
     """Configure Loguru logger with custom format and levels."""
@@ -87,7 +72,7 @@ class ComposioTool(Tool):
     )
     action: str = Field(default="")  # Single action per tool instance
     action_schema: Optional[ActionSchema] = None
-    toolset: Optional['ComposioToolSet'] = None
+    toolset: Optional[ComposioToolSet] = None
     
     # Performance tracking
     _last_execution_time: Optional[datetime] = None
@@ -111,20 +96,6 @@ class ComposioTool(Tool):
             need_validation: Whether this specific instance needs validation
             **data: Additional data for tool initialization
         """
-        # Check if composio is available
-        if not COMPOSIO_AVAILABLE:
-            logger.error("ComposioTool cannot be initialized: composio module is not installed")
-            raise ImportError("The 'composio' package is required to use ComposioTool. "
-                             "Install it with 'pip install composio' or include it in your dependencies.")
-        
-        # Import composio only when needed
-        try:
-            from composio import Action, ComposioToolSet
-        except ImportError:
-            logger.error("Failed to import composio module")
-            raise ImportError("The 'composio' package is required to use ComposioTool. "
-                             "Install it with 'pip install composio' or include it in your dependencies.")
-            
         logger.info(f"Initializing ComposioTool for action: {action}")
         start_time = datetime.now()
         
@@ -179,14 +150,6 @@ class ComposioTool(Tool):
 
     def _setup_action(self) -> None:
         """Set up the Composio action with its schema and parameters."""
-        # Import composio only when needed
-        try:
-            from composio import Action, ComposioToolSet
-        except ImportError:
-            logger.error("Failed to import composio module")
-            raise ImportError("The 'composio' package is required to use ComposioTool. "
-                             "Install it with 'pip install composio' or include it in your dependencies.")
-            
         logger.debug(f"Setting up action: {self.action}")
         start_time = datetime.now()
         
@@ -382,14 +345,6 @@ class ComposioTool(Tool):
 
     def execute(self, **kwargs: Any) -> str:
         """Execute the Composio action with the given parameters."""
-        # Import composio only when needed
-        try:
-            from composio import Action, ComposioToolSet
-        except ImportError:
-            logger.error("Failed to import composio module")
-            raise ImportError("The 'composio' package is required to use ComposioTool. "
-                             "Install it with 'pip install composio' or include it in your dependencies.")
-        
         start_time = datetime.now()
         self._execution_count += 1
         self._last_execution_time = start_time

quantalogic/tools/database/__init__.py

@@ -0,0 +1,20 @@
+"""
+Database Tools Module
+
+This module provides database-related tools and utilities.
+"""
+
+from loguru import logger
+
+# Explicit imports of all tools in the module
+from .generate_database_report_tool import GenerateDatabaseReportTool
+from .sql_query_tool_advanced import SQLQueryToolAdvanced
+
+# Define __all__ to control what is imported with `from ... import *`
+__all__ = [
+    'GenerateDatabaseReportTool',
+    'SQLQueryToolAdvanced',
+]
+
+# Optional: Add logging for import confirmation
+logger.info("Database tools module initialized successfully.")

quantalogic/tools/database/sql_query_tool_advanced.py

@@ -1,27 +1,13 @@
 """Tool for executing SQL queries and performing database operations with safety checks."""
 
-import importlib.util
 import json
 from enum import Enum
-from typing import Any, Dict, List, Optional, TYPE_CHECKING
+from typing import Any, Dict, List, Optional
 
 from loguru import logger
 from pydantic import Field
-
-# Check if sqlalchemy is available
-SQLALCHEMY_AVAILABLE = False
-try:
-    spec = importlib.util.find_spec("sqlalchemy")
-    SQLALCHEMY_AVAILABLE = spec is not None
-    if SQLALCHEMY_AVAILABLE:
-        from sqlalchemy import create_engine, inspect, text
-        from sqlalchemy.engine import Engine
-except ImportError:
-    pass
-
-# Type checking imports
-if TYPE_CHECKING:
-    from sqlalchemy.engine import Engine
+from sqlalchemy import create_engine, inspect, text
+from sqlalchemy.engine import Engine
 
 from quantalogic.tools.tool import Tool, ToolArgument
 
@@ -86,9 +72,6 @@ class SQLQueryToolAdvanced(Tool):
 
     def __init__(self, **data):
         super().__init__(**data)
-        if not SQLALCHEMY_AVAILABLE:
-            raise ImportError("The 'sqlalchemy' package is required to use SQLQueryToolAdvanced. "
-                           "Install it with 'pip install sqlalchemy' or include it in your dependencies.")
         self._engine = create_engine(self.connection_string)
         logger.info(f"Initialized SQL tool with engine for {self.connection_string}")
 
@@ -217,10 +200,10 @@ class SQLQueryToolAdvanced(Tool):
             raise ValueError("DROP DATABASE operations are not allowed")
         
         inspector = inspect(self._engine)
-        existing_tables = inspector.get_table_names()
+        _existing_tables = inspector.get_table_names()
         
         # Additional safety checks could be added here
-        logger.debug(f"Schema validation passed for operation")
+        logger.debug("Schema validation passed for operation")
 
     def _convert_row_number(self, value: Any, field_name: str) -> int:
         """Convert and validate row number input."""

quantalogic/tools/document_tools/__init__.py

@@ -1,39 +1,30 @@
 """
 Document Tools Module
 
-This module provides optional tools for converting markdown to various document formats.
+This module provides tools for converting Markdown to various document formats.
 """
 
-from typing import Any
-import importlib
-import logging
+from loguru import logger
 
-logger = logging.getLogger(__name__)
+# Explicit imports of all tools in the module
+from .markdown_to_docx_tool import MarkdownToDocxTool
+from .markdown_to_epub_tool import MarkdownToEpubTool
+from .markdown_to_html_tool import MarkdownToHtmlTool
+from .markdown_to_ipynb_tool import MarkdownToIpynbTool
+from .markdown_to_latex_tool import MarkdownToLatexTool
+from .markdown_to_pdf_tool import MarkdownToPdfTool
+from .markdown_to_pptx_tool import MarkdownToPptxTool
 
-# List of available tools for introspection
+# Define __all__ to control what is imported with `from ... import *`
 __all__ = [
-    'markdown_to_docx_tool',
-    'markdown_to_epub_tool', 
-    'markdown_to_html_tool',
-    'markdown_to_ipynb_tool',
-    'markdown_to_latex_tool',
-    'markdown_to_pdf_tool',
-    'markdown_to_pptx_tool'
+    'MarkdownToDocxTool',
+    'MarkdownToEpubTool',
+    'MarkdownToHtmlTool',
+    'MarkdownToIpynbTool',
+    'MarkdownToLatexTool',
+    'MarkdownToPdfTool',
+    'MarkdownToPptxTool',
 ]
 
-def __getattr__(name: str) -> Any:
-    """
-    Dynamically import optional tools with graceful error handling.
-    
-    Args:
-        name (str): Name of the tool to import
-    
-    Returns:
-        Any: Imported tool or None if import fails
-    """
-    try:
-        module = importlib.import_module(f'.{name}', package='quantalogic.tools.document_tools')
-        return getattr(module, name)
-    except (ImportError, AttributeError) as e:
-        logger.warning(f"Optional tool {name} could not be imported: {e}")
-        return None
+# Optional: Add logging for import confirmation
+logger.info("Document tools module initialized successfully.")

quantalogic/tools/finance/__init__.py

@@ -0,0 +1,32 @@
+"""
+Finance Tools Module
+
+This module provides finance-related tools and utilities.
+"""
+
+from loguru import logger
+
+# Explicit imports of all tools in the module
+from .alpha_vantage_tool import AlphaVantageTool
+from .ccxt_tool import CcxtTool
+from .finance_llm_tool import FinanceLLMTool
+from .google_finance import GoogleFinanceTool
+from .market_intelligence_tool import MarketIntelligenceTool
+from .technical_analysis_tool import TechnicalAnalysisTool
+from .tradingview_tool import TradingViewTool
+from .yahoo_finance import YahooFinanceTool
+
+# Define __all__ to control what is imported with `from ... import *`
+__all__ = [
+    'AlphaVantageTool',
+    'CcxtTool',
+    'FinanceLLMTool',
+    'GoogleFinanceTool',
+    'MarketIntelligenceTool',
+    'TechnicalAnalysisTool',
+    'TradingViewTool',
+    'YahooFinanceTool',
+]
+
+# Optional: Add logging for import confirmation
+logger.info("Finance tools module initialized successfully.")

quantalogic/tools/git/__init__.py

@@ -0,0 +1,24 @@
+"""
+Git Tools Module
+
+This module provides tools and utilities related to Git operations.
+"""
+
+from loguru import logger
+
+# Explicit imports of all tools in the module
+from .bitbucket_clone_repo_tool import BitbucketCloneTool
+from .bitbucket_operations_tool import BitbucketOperationsTool
+from .clone_repo_tool import CloneRepoTool
+from .git_operations_tool import GitOperationsTool
+
+# Define __all__ to control what is imported with `from ... import *`
+__all__ = [
+    'BitbucketCloneTool',
+    'BitbucketOperationsTool',
+    'CloneRepoTool',
+    'GitOperationsTool',
+]
+
+# Optional: Add logging for import confirmation
+logger.info("Git tools module initialized successfully.")

quantalogic/tools/google_packages/__init__.py

@@ -0,0 +1,18 @@
+"""
+Google Packages Tools Module
+
+This module provides tools and utilities related to Google packages.
+"""
+
+from loguru import logger
+
+# Explicit imports of all tools in the module
+from .google_news_tool import GoogleNewsTool
+
+# Define __all__ to control what is imported with `from ... import *`
+__all__ = [
+    'GoogleNewsTool',
+]
+
+# Optional: Add logging for import confirmation
+logger.info("Google Packages tools module initialized successfully.")

quantalogic/tools/image_generation/__init__.py

@@ -0,0 +1,18 @@
+"""
+Image Generation Tools Module
+
+This module provides tools and utilities for image generation.
+"""
+
+from loguru import logger
+
+# Explicit imports of all tools in the module
+from .dalle_e import LLMImageGenerationTool
+
+# Define __all__ to control what is imported with `from ... import *`
+__all__ = [
+    'LLMImageGenerationTool',
+]
+
+# Optional: Add logging for import confirmation
+logger.info("Image Generation tools module initialized successfully.")

quantalogic/tools/nasa_packages/__init__.py

@@ -0,0 +1,20 @@
+"""
+NASA Packages Tools Module
+
+This module provides tools and utilities related to NASA packages.
+"""
+
+from loguru import logger
+
+# Explicit imports of all tools in the module
+from .nasa_apod_tool import NasaApodTool
+from .nasa_neows_tool import NasaNeoWsTool
+
+# Define __all__ to control what is imported with `from ... import *`
+__all__ = [
+    'NasaApodTool',
+    'NasaNeoWsTool',
+]
+
+# Optional: Add logging for import confirmation
+logger.info("NASA Packages tools module initialized successfully.")

quantalogic/tools/presentation_tools/__init__.py

@@ -0,0 +1,18 @@
+"""
+Presentation Tools Module
+
+This module provides tools and utilities for creating and managing presentations.
+"""
+
+from loguru import logger
+
+# Explicit imports of all tools in the module
+from .presentation_llm_tool import PresentationLLMTool
+
+# Define __all__ to control what is imported with `from ... import *`
+__all__ = [
+    'PresentationLLMTool',
+]
+
+# Optional: Add logging for import confirmation
+logger.info("Presentation tools module initialized successfully.")

quantalogic/tools/product_hunt/__init__.py

@@ -0,0 +1,18 @@
+"""
+Product Hunt Tools Module
+
+This module provides tools and utilities related to Product Hunt.
+"""
+
+from loguru import logger
+
+# Explicit imports of all tools in the module
+from .product_hunt_tool import ProductHuntTool
+
+# Define __all__ to control what is imported with `from ... import *`
+__all__ = [
+    'ProductHuntTool',
+]
+
+# Optional: Add logging for import confirmation
+logger.info("Product Hunt tools module initialized successfully.")

quantalogic/tools/rag_tool/__init__.py

@@ -1,48 +1,24 @@
-"""RAG Tool and related components."""
-
-import importlib
-import sys
-from typing import Any
-
-
-class LazyLoader:
-    """
-    Lazily import a module only when its attributes are accessed.
-    This helps reduce startup time by deferring imports until needed.
-    """
-    def __init__(self, module_path: str):
-        self.module_path = module_path
-        self._module = None
-
-    def __getattr__(self, name: str) -> Any:
-        if self._module is None:
-            self._module = importlib.import_module(self.module_path)
-        return getattr(self._module, name)
-
-
-# Map of class names to their import paths
-_IMPORTS = {
-    "DocumentMetadata": ".document_metadata",
-    "QueryResponse": ".query_response",
-    "RagTool": ".rag_tool"
-}
-
-# Create lazy loaders for each module
-_lazy_modules = {}
-for cls_name, path in _IMPORTS.items():
-    full_path = f"{__package__}{path}"
-    if (full_path not in _lazy_modules):
-        _lazy_modules[full_path] = LazyLoader(full_path)
-
-# Map each class to its lazy module
-_class_to_lazy_module = {}
-for cls_name, path in _IMPORTS.items():
-    full_path = f"{__package__}{path}"
-    _class_to_lazy_module[cls_name] = _lazy_modules[full_path]
-
-# Define __all__ so that import * works properly
-__all__ = list(_IMPORTS.keys())
-
-# Set up lazy loading for each class
-for cls_name, lazy_module in _class_to_lazy_module.items():
-    setattr(sys.modules[__name__], cls_name, getattr(lazy_module, cls_name))
+"""
+RAG Tool and related components.
+
+This module provides tools and utilities for Retrieval-Augmented Generation (RAG).
+"""
+
+from loguru import logger
+
+# Explicit imports of all tools in the module
+from .document_metadata import DocumentMetadata
+from .query_response import QueryResponse
+from .rag_tool import RagTool
+from .rag_tool_beta import RagToolBeta
+
+# Define __all__ to control what is imported with `from ... import *`
+__all__ = [
+    'DocumentMetadata',
+    'QueryResponse',
+    'RagTool',
+    'RagToolBeta',
+]
+
+# Optional: Add logging for import confirmation
+logger.info("RAG tools module initialized successfully.")