quantalogic 0.35.0__py3-none-any.whl → 0.50.0__py3-none-any.whl

quantalogic/tools/llm_vision_tool.py

@@ -1,6 +1,7 @@
 """LLM Vision Tool for analyzing images using a language model."""
 
-from typing import Optional
+import asyncio
+from typing import Callable, Optional
 
 from loguru import logger
 from pydantic import ConfigDict, Field
@@ -59,8 +60,37 @@ class LLMVisionTool(Tool):
     )
 
     model_name: str = Field(..., description="The name of the language model to use")
+    on_token: Callable | None = Field(default=None, exclude=True)
     generative_model: Optional[GenerativeModel] = Field(default=None)
 
+    def __init__(
+        self,
+        model_name: str,
+        on_token: Callable | None = None,
+        name: str = "llm_vision_tool",
+        generative_model: GenerativeModel | None = None,
+    ):
+        """Initialize the LLMVisionTool with model configuration and optional callback.
+
+        Args:
+            model_name (str): The name of the language model to use.
+            on_token (Callable, optional): Callback function for streaming tokens.
+            name (str): Name of the tool instance. Defaults to "llm_vision_tool".
+            generative_model (GenerativeModel, optional): Pre-initialized generative model.
+        """
+        # Use dict to pass validated data to parent constructor
+        super().__init__(
+            **{
+                "model_name": model_name,
+                "on_token": on_token,
+                "name": name,
+                "generative_model": generative_model,
+            }
+        )
+
+        # 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:
@@ -75,6 +105,30 @@ class LLMVisionTool(Tool):
     def execute(self, system_prompt: str, prompt: str, image_url: str, temperature: str = "0.7") -> str:
         """Execute the tool to analyze an image and generate a response.
 
+        Args:
+            system_prompt: The system prompt to guide the model
+            prompt: The question or instruction about the image
+            image_url: URL of the image to analyze
+            temperature: Sampling temperature
+
+        Returns:
+            The generated response
+
+        Raises:
+            ValueError: If temperature is invalid or image_url is malformed
+            Exception: If there's an error during response generation
+        """
+        # Run the async version synchronously
+        return asyncio.run(
+            self.async_execute(system_prompt=system_prompt, prompt=prompt, image_url=image_url, temperature=temperature)
+        )
+
+    async def async_execute(self, system_prompt: str, prompt: str, image_url: str, temperature: str = "0.7") -> str:
+        """Execute the tool to analyze an image and generate a response asynchronously.
+
+        This method provides a native asynchronous implementation, utilizing the generative model's
+        asynchronous capabilities for improved performance in async contexts.
+
         Args:
             system_prompt: The system prompt to guide the model
             prompt: The question or instruction about the image
@@ -111,17 +165,15 @@ class LLMVisionTool(Tool):
 
         try:
             is_streaming = self.on_token is not None
-            response_stats = self.generative_model.generate_with_history(
-                messages_history=messages_history,
-                prompt=prompt,
-                image_url=image_url,
-                streaming=is_streaming
+            response_stats = await self.generative_model.async_generate_with_history(
+                messages_history=messages_history, prompt=prompt, image_url=image_url, streaming=is_streaming
             )
 
             if is_streaming:
                 response = ""
-                for chunk in response_stats:
+                async for chunk in response_stats:
                     response += chunk
+                    # Note: on_token is handled via the event emitter set in model_post_init
             else:
                 response = response_stats.response.strip()
 

quantalogic/tools/markitdown_tool.py

@@ -65,25 +65,37 @@ class MarkitdownTool(Tool):
                     file_path = os.path.expanduser(file_path)
                 if not os.path.isabs(file_path):
                     file_path = os.path.abspath(file_path)
-                
+
                 # Verify file exists
                 if not os.path.exists(file_path):
                     return f"Error: File not found at path: {file_path}"
 
             from markitdown import MarkItDown
+
             md = MarkItDown()
-            result = md.convert(file_path)
+
+            # Detect file type if possible
+            file_extension = os.path.splitext(file_path)[1].lower()
+            supported_extensions = [".pdf", ".pptx", ".docx", ".xlsx", ".html", ".htm"]
+
+            if not file_extension or file_extension not in supported_extensions:
+                return f"Error: Unsupported file format. Supported formats are: {', '.join(supported_extensions)}"
+
+            try:
+                result = md.convert(file_path)
+            except Exception as e:
+                return f"Error converting file to Markdown: {str(e)}"
 
             if output_file_path:
                 # Ensure output directory exists
                 output_dir = os.path.dirname(output_file_path)
                 if output_dir and not os.path.exists(output_dir):
                     os.makedirs(output_dir)
-                    
+
                 with open(output_file_path, "w", encoding="utf-8") as f:
                     f.write(result.text_content)
                 return f"Markdown content successfully written to {output_file_path}"
-            
+
             # Handle content truncation
             lines = result.text_content.splitlines()
             if len(lines) > MAX_LINES:
@@ -92,7 +104,7 @@ class MarkitdownTool(Tool):
             return result.text_content
 
         except Exception as e:
-            return f"Error converting file to Markdown: {str(e)}"
+            return f"Error processing file: {str(e)}"
         finally:
             if is_temp_file and os.path.exists(file_path):
                 os.remove(file_path)

quantalogic/tools/nasa_packages/models.py

@@ -0,0 +1,47 @@
+"""Data models for NASA API responses."""
+
+from typing import List
+
+from pydantic import BaseModel, Field
+
+
+class AsteroidDiameter(BaseModel):
+    """Asteroid diameter estimates in meters."""
+    min_diameter: float = Field(..., alias="estimated_diameter_min")
+    max_diameter: float = Field(..., alias="estimated_diameter_max")
+
+class CloseApproach(BaseModel):
+    """Close approach data for an asteroid."""
+    date: str = Field(..., alias="close_approach_date_full")
+    velocity_kph: float = Field(..., alias="relative_velocity.kilometers_per_hour")
+    miss_distance_km: float = Field(..., alias="miss_distance.kilometers")
+
+class Asteroid(BaseModel):
+    """Model for asteroid data."""
+    name: str
+    nasa_jpl_url: str
+    is_hazardous: bool = Field(..., alias="is_potentially_hazardous_asteroid")
+    diameter: AsteroidDiameter = Field(..., alias="estimated_diameter.meters")
+    approaches: List[CloseApproach] = Field(..., alias="close_approach_data")
+
+    def format_info(self) -> str:
+        """Format asteroid information into readable text."""
+        lines = [
+            f"Name: {self.name}",
+            f"NASA JPL URL: {self.nasa_jpl_url}",
+            f"Potentially Hazardous: {self.is_hazardous}",
+            f"Estimated Diameter:",
+            f"  Min: {self.diameter.min_diameter:.2f} meters",
+            f"  Max: {self.diameter.max_diameter:.2f} meters"
+        ]
+        
+        if self.approaches:
+            approach = self.approaches[0]
+            lines.extend([
+                "\nClosest Approach:",
+                f"  Date: {approach.date}",
+                f"  Velocity: {approach.velocity_kph} km/h",
+                f"  Miss Distance: {approach.miss_distance_km} km"
+            ])
+        
+        return "\n".join(lines)

quantalogic/tools/nasa_packages/nasa_apod_tool.py

@@ -0,0 +1,232 @@
+"""NASA APOD (Astronomy Picture of the Day) API tool.
+
+This tool provides access to NASA's APOD API to retrieve astronomy pictures and related information.
+It supports fetching both current and historical astronomy pictures with detailed metadata.
+"""
+
+import os
+from datetime import datetime
+from typing import Any, Dict, List
+
+import requests
+from loguru import logger
+
+from quantalogic.tools.tool import Tool, ToolArgument
+
+
+class NasaApodTool(Tool):
+    """Tool for accessing NASA's Astronomy Picture of the Day (APOD) API.
+
+    Features:
+    - Fetch today's astronomy picture
+    - Retrieve pictures from specific dates
+    - Get random astronomy pictures
+    - Support for HD images
+    - Detailed metadata including explanation and copyright info
+    """
+
+    name: str = "nasa_apod_tool"
+    description: str = (
+        "NASA Astronomy Picture of the Day (APOD) API tool for retrieving astronomy pictures "
+        "and their detailed information including scientific explanations."
+    )
+    arguments: List[ToolArgument] = [
+        ToolArgument(
+            name="date",
+            arg_type="string",
+            description="The date of the APOD image to retrieve (YYYY-MM-DD format)",
+            required=False,
+            default="today",
+            example="2024-01-15",
+        ),
+        ToolArgument(
+            name="start_date",
+            arg_type="string",
+            description="Start date for date range search (YYYY-MM-DD format)",
+            required=False,
+            example="2024-01-01",
+        ),
+        ToolArgument(
+            name="end_date",
+            arg_type="string",
+            description="End date for date range search (YYYY-MM-DD format)",
+            required=False,
+            example="2024-01-07",
+        ),
+        ToolArgument(
+            name="count",
+            arg_type="int",
+            description="Number of random images to return (1-100)",
+            required=False,
+            default="1",
+            example="5",
+        ),
+        ToolArgument(
+            name="thumbs",
+            arg_type="boolean",
+            description="Return thumbnail URLs for video content",
+            required=False,
+            default="True",
+            example="True",
+        ),
+    ]
+
+    def __init__(self):
+        """Initialize the NASA APOD tool."""
+        super().__init__()
+        self.api_key = os.getenv("LANAZA_API_KEY", "DEMO_KEY")
+        self.base_url = "https://api.nasa.gov/planetary/apod"
+
+    def _fetch_apod_data(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Fetch data from NASA APOD API.
+
+        Args:
+            params: Query parameters for the API request
+
+        Returns:
+            API response data as dictionary
+
+        Raises:
+            RuntimeError: If the API request fails
+        """
+        try:
+            params["api_key"] = self.api_key
+            response = requests.get(self.base_url, params=params)
+            if response.status_code == 200:
+                return response.json()
+            else:
+                raise RuntimeError(f"API request failed with status {response.status_code}: {response.text}")
+        except Exception as e:
+            raise RuntimeError(f"Failed to fetch APOD data: {str(e)}")
+
+    def _validate_date(self, date_str: str) -> str:
+        """Validate and format date string.
+
+        Args:
+            date_str: Date string to validate
+
+        Returns:
+            Validated date string in YYYY-MM-DD format
+
+        Raises:
+            ValueError: If date format is invalid
+        """
+        if date_str.lower() == "today":
+            return datetime.now().strftime("%Y-%m-%d")
+        try:
+            datetime.strptime(date_str, "%Y-%m-%d")
+            return date_str
+        except ValueError:
+            raise ValueError("Invalid date format. Use YYYY-MM-DD format.")
+
+    def _format_apod_result(self, data: Dict[str, Any] | List[Dict[str, Any]]) -> str:
+        """Format APOD data into readable text.
+
+        Args:
+            data: APOD data from API
+
+        Returns:
+            Formatted string with APOD information
+        """
+        if isinstance(data, list):
+            return self._format_multiple_results(data)
+        
+        result = []
+        result.append(f"Title: {data.get('title', 'N/A')}")
+        result.append(f"Date: {data.get('date', 'N/A')}")
+        if 'copyright' in data:
+            result.append(f"Copyright: {data['copyright']}")
+        
+        # Add media links
+        if data.get('media_type') == 'video':
+            result.append(f"Video URL: {data.get('url', 'N/A')}")
+            if data.get('thumbnail_url'):
+                result.append(f"Thumbnail URL: {data.get('thumbnail_url')}")
+        else:
+            result.append(f"Image URL: {data.get('url', 'N/A')}")
+            if data.get('hdurl'):
+                result.append(f"HD Image URL: {data.get('hdurl')}")
+        
+        # Add explanation
+        if data.get('explanation'):
+            result.append("\nExplanation:")
+            result.append(data['explanation'])
+        
+        return "\n".join(result)
+
+    def _format_multiple_results(self, data_list: List[Dict[str, Any]]) -> str:
+        """Format multiple APOD results.
+
+        Args:
+            data_list: List of APOD data entries
+
+        Returns:
+            Formatted string with multiple APOD entries
+        """
+        results = []
+        for i, data in enumerate(data_list, 1):
+            results.append(f"\n--- APOD Entry {i} ---")
+            results.append(self._format_apod_result(data))
+        return "\n".join(results)
+
+    def execute(
+        self,
+        date: str = "today",
+        start_date: str = None,
+        end_date: str = None,
+        count: int = 1,
+        thumbs: bool = True,
+    ) -> str:
+        """Execute APOD API request with specified parameters.
+
+        Args:
+            date: Specific date for APOD image (YYYY-MM-DD)
+            start_date: Start date for date range
+            end_date: End date for date range
+            count: Number of random images to return
+            thumbs: Include thumbnails for video content
+
+        Returns:
+            Formatted string containing APOD data
+
+        Raises:
+            ValueError: If parameters are invalid
+            RuntimeError: If the API request fails
+        """
+        # Validate parameters
+        params = {"thumbs": str(thumbs).lower()}
+
+        # Handle different query types
+        if start_date and end_date:
+            params["start_date"] = self._validate_date(start_date)
+            params["end_date"] = self._validate_date(end_date)
+        elif count > 1:
+            params["count"] = min(100, max(1, count))  # Ensure count is between 1 and 100
+        else:
+            params["date"] = self._validate_date(date)
+
+        try:
+            data = self._fetch_apod_data(params)
+            return self._format_apod_result(data)
+        except Exception as e:
+            logger.error(f"Error executing APOD tool: {str(e)}")
+            raise
+
+if __name__ == "__main__":
+    # Example usage
+    tool = NasaApodTool()
+    
+    # Test with today's APOD
+    result = tool.execute()
+    print("Today's APOD:")
+    print(result)
+    
+    # Test with specific date
+    result = tool.execute(date="2024-01-01")
+    print("\nAPOD for 2024-01-01:")
+    print(result)
+    
+    # Test with multiple random images
+    result = tool.execute(count=2)
+    print("\nTwo random APODs:")
+    print(result)

quantalogic/tools/nasa_packages/nasa_neows_tool.py

@@ -0,0 +1,147 @@
+"""NASA NeoWs (Near Earth Object Web Service) API tool.
+
+This tool provides access to NASA's NeoWs API to retrieve information about near-Earth asteroids.
+It supports searching by date ranges, looking up specific asteroids, and browsing the overall dataset.
+"""
+
+import asyncio
+import os
+from typing import List
+
+from loguru import logger
+
+from quantalogic.tools.tool import Tool, ToolArgument
+
+from .models import Asteroid
+from .services import NasaApiService, NeoWsService
+
+
+class NasaNeoWsTool(Tool):
+    """Tool for accessing NASA's Near Earth Object Web Service (NeoWs).
+
+    Features:
+    - Search asteroids by date range
+    - Lookup specific asteroids by ID
+    - Browse the overall asteroid dataset
+    """
+
+    name: str = "nasa_neows_tool"
+    description: str = (
+        "NASA Near Earth Object Web Service (NeoWs) API tool for retrieving information "
+        "about near-Earth asteroids, including their orbits, sizes, and approach distances."
+    )
+    arguments: List[ToolArgument] = [
+        ToolArgument(
+            name="operation",
+            arg_type="string",
+            description="Operation to perform (feed, lookup, browse)",
+            required=True,
+            default="feed",
+            example="feed",
+        ),
+        ToolArgument(
+            name="start_date",
+            arg_type="string",
+            description="Start date for asteroid search (YYYY-MM-DD format)",
+            required=False,
+            example="2024-01-01",
+        ),
+        ToolArgument(
+            name="end_date",
+            arg_type="string",
+            description="End date for asteroid search (YYYY-MM-DD format)",
+            required=False,
+            example="2024-01-07",
+        ),
+        ToolArgument(
+            name="asteroid_id",
+            arg_type="string",
+            description="NASA JPL small body ID for asteroid lookup",
+            required=False,
+            example="3542519",
+        ),
+    ]
+
+    def __init__(self):
+        """Initialize the NASA NeoWs tool."""
+        super().__init__()
+        api_service = NasaApiService(os.getenv("LANAZA_API_KEY", "DEMO_KEY"))
+        self.service = NeoWsService(api_service)
+
+    def _format_feed_results(self, data: dict) -> str:
+        """Format feed results into readable text."""
+        result = [f"Element Count: {data.get('element_count', 0)} asteroids found"]
+        
+        for date, asteroids in data.get('near_earth_objects', {}).items():
+            result.extend([
+                f"\nDate: {date}",
+                f"Number of asteroids: {len(asteroids)}"
+            ])
+            
+            for ast_data in asteroids:
+                asteroid = Asteroid(**ast_data)
+                result.extend([
+                    "\n" + asteroid.format_info(),
+                    "-" * 50
+                ])
+        
+        return "\n".join(result)
+
+    async def execute(
+        self,
+        operation: str = "feed",
+        start_date: str = None,
+        end_date: str = None,
+        asteroid_id: str = None,
+    ) -> str:
+        """Execute NeoWs API request with specified parameters."""
+        try:
+            if operation == "feed":
+                data = await self.service.get_feed(start_date, end_date)
+                return self._format_feed_results(data)
+            
+            elif operation == "lookup":
+                if not asteroid_id:
+                    raise ValueError("asteroid_id is required for lookup operation")
+                data = await self.service.lookup_asteroid(asteroid_id)
+                return Asteroid(**data).format_info()
+            
+            elif operation == "browse":
+                data = await self.service.browse_asteroids()
+                result = ["Browse Results:"]
+                for ast_data in data.get('near_earth_objects', []):
+                    asteroid = Asteroid(**ast_data)
+                    result.extend([
+                        "\n" + asteroid.format_info(),
+                        "-" * 50
+                    ])
+                return "\n".join(result)
+            
+            else:
+                raise ValueError(f"Invalid operation: {operation}. Must be one of: feed, lookup, browse")
+            
+        except Exception as e:
+            logger.error(f"Error executing NeoWs tool: {str(e)}")
+            raise
+
+if __name__ == "__main__":
+    # Example usage
+    tool = NasaNeoWsTool()
+    
+    async def test_tool():
+        # Test feed operation
+        print("Testing Feed Operation:")
+        result = await tool.execute(operation="feed")
+        print(result)
+        
+        # Test lookup operation
+        print("\nTesting Lookup Operation:")
+        result = await tool.execute(operation="lookup", asteroid_id="3542519")
+        print(result)
+        
+        # Test browse operation
+        print("\nTesting Browse Operation:")
+        result = await tool.execute(operation="browse")
+        print(result)
+
+    asyncio.run(test_tool())

quantalogic/tools/nasa_packages/services.py

@@ -0,0 +1,82 @@
+"""Services for interacting with NASA APIs."""
+
+from datetime import datetime, timedelta
+from typing import Any, Dict, List
+
+import aiohttp
+from loguru import logger
+
+
+class NasaApiService:
+    """Service for making NASA API requests."""
+    
+    def __init__(self, api_key: str):
+        """Initialize with API key."""
+        self.api_key = api_key
+        self.base_url = "https://api.nasa.gov/neo/rest/v1"
+
+    async def fetch_data(self, endpoint: str, params: Dict[str, Any] = None) -> Dict[str, Any]:
+        """Make an API request to NASA endpoints.
+        
+        Args:
+            endpoint: API endpoint path
+            params: Optional query parameters
+            
+        Returns:
+            API response data
+            
+        Raises:
+            RuntimeError: If request fails
+        """
+        params = params or {}
+        params["api_key"] = self.api_key
+        url = f"{self.base_url}/{endpoint}"
+        
+        try:
+            async with aiohttp.ClientSession() as session:
+                async with session.get(url, params=params) as response:
+                    if response.status == 200:
+                        return await response.json()
+                    error_text = await response.text()
+                    raise RuntimeError(f"API error {response.status}: {error_text}")
+        except Exception as e:
+            logger.error(f"NASA API request failed: {str(e)}")
+            raise RuntimeError(f"Failed to fetch data: {str(e)}")
+
+class NeoWsService:
+    """Service for Near Earth Object Web Service operations."""
+    
+    def __init__(self, api_service: NasaApiService):
+        """Initialize with API service."""
+        self.api = api_service
+
+    @staticmethod
+    def validate_date(date_str: str) -> str:
+        """Validate date string format."""
+        try:
+            datetime.strptime(date_str, "%Y-%m-%d")
+            return date_str
+        except ValueError:
+            raise ValueError("Invalid date format. Use YYYY-MM-DD")
+
+    async def get_feed(self, start_date: str, end_date: str = None) -> Dict[str, Any]:
+        """Get asteroid feed for date range."""
+        start_date = self.validate_date(start_date)
+        if not end_date:
+            end_date = (datetime.strptime(start_date, "%Y-%m-%d") + 
+                       timedelta(days=7)).strftime("%Y-%m-%d")
+        else:
+            end_date = self.validate_date(end_date)
+            
+        return await self.api.fetch_data("feed", {
+            "start_date": start_date,
+            "end_date": end_date
+        })
+
+    async def lookup_asteroid(self, asteroid_id: str) -> Dict[str, Any]:
+        """Look up specific asteroid by ID."""
+        return await self.api.fetch_data(f"neo/{asteroid_id}")
+
+    async def browse_asteroids(self) -> Dict[str, Any]:
+        """Browse asteroid dataset."""
+        return await self.api.fetch_data("neo/browse")