meteor tool

app.py

@@ -7,17 +7,136 @@ from tools.final_answer import FinalAnswerTool
 
 from Gradio_UI import GradioUI
 
-# Below is an example of a tool that does nothing. Amaze us with your creativity !
 @tool
-def my_custom_tool(arg1:str, arg2:int)-> str: #it's import to specify the return type
-    #Keep this format for the description / args / args description but feel free to modify the tool
-    """A tool that does nothing yet 
+def find_nearest_meteor(address: str) -> str:
+    """A tool that finds the nearest meteor landing site based on a given address.
+    
     Args:
-        arg1: the first argument
-        arg2: the second argument
+        address: A string representing an address (e.g., '123 Main St, New York, NY')
     """
-    return "What magic will you build ?"
-
+    import requests
+    import math
+    from urllib.parse import quote
+    
+    def geocode_address(address):
+        """Convert address to latitude and longitude using OpenCage API."""
+        base_url = "https://api.opencagedata.com/geocode/v1/json"
+        api_key = "03c48dae07364cabb7f121d8c1519492"
+        
+        # URL encode the address
+        encoded_address = quote(address)
+        
+        # Construct the full request URL
+        url = f"{base_url}?q={encoded_address}&key={api_key}&no_annotations=1&language=en"
+        
+        headers = {
+            'accept': 'application/json, text/javascript, */*; q=0.01',
+            'accept-language': 'pt-BR,pt;q=0.9,en-US;q=0.8,en;q=0.7',
+            'origin': 'https://www.gps-coordinates.net',
+            'referer': 'https://www.gps-coordinates.net/',
+            'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/133.0.0.0 Safari/537.36'
+        }
+        
+        try:
+            response = requests.get(url, headers=headers)
+            data = response.json()
+            
+            if data['total_results'] > 0:
+                location = data['results'][0]['geometry']
+                return {
+                    'lat': location['lat'],
+                    'lng': location['lng'],
+                    'formatted_address': data['results'][0]['formatted']
+                }
+            else:
+                return None
+        except Exception as e:
+            return f"Error geocoding address: {str(e)}"
+    
+    def get_meteor_data():
+        """Fetch meteor landing site data from NASA API."""
+        url = "https://data.nasa.gov/resource/gh4g-9sfh.json"
+        try:
+            response = requests.get(url)
+            return response.json()
+        except Exception as e:
+            return f"Error fetching meteor data: {str(e)}"
+    
+    def calculate_distance(lat1, lon1, lat2, lon2):
+        """Calculate the great circle distance between two points on earth."""
+        # Radius of earth in kilometers
+        R = 6371.0
+        
+        # Convert latitude and longitude from degrees to radians
+        lat1_rad = math.radians(lat1)
+        lon1_rad = math.radians(lon1)
+        lat2_rad = math.radians(lat2)
+        lon2_rad = math.radians(lon2)
+        
+        # Difference in coordinates
+        dlon = lon2_rad - lon1_rad
+        dlat = lat2_rad - lat1_rad
+        
+        # Haversine formula
+        a = math.sin(dlat / 2)**2 + math.cos(lat1_rad) * math.cos(lat2_rad) * math.sin(dlon / 2)**2
+        c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
+        distance = R * c
+        
+        return distance
+    
+    # Geocode the address
+    location_data = geocode_address(address)
+    if not location_data or isinstance(location_data, str):
+        return f"Could not geocode address: {address}. {location_data if isinstance(location_data, str) else ''}"
+    
+    # Get meteor data
+    meteor_data = get_meteor_data()
+    if isinstance(meteor_data, str):
+        return meteor_data
+    
+    # Calculate distance to each meteor
+    nearest_meteor = None
+    min_distance = float('inf')
+    
+    for meteor in meteor_data:
+        # Check if meteor has geolocation data
+        if 'geolocation' in meteor and meteor['geolocation'] and 'latitude' in meteor['geolocation'] and 'longitude' in meteor['geolocation']:
+            try:
+                meteor_lat = float(meteor['geolocation']['latitude'])
+                meteor_lng = float(meteor['geolocation']['longitude'])
+                
+                distance = calculate_distance(
+                    location_data['lat'], 
+                    location_data['lng'], 
+                    meteor_lat, 
+                    meteor_lng
+                )
+                
+                if distance < min_distance:
+                    min_distance = distance
+                    nearest_meteor = meteor
+            except (ValueError, TypeError):
+                # Skip entries with invalid coordinates
+                continue
+    
+    if nearest_meteor:
+        # Format the response
+        name = nearest_meteor.get('name', 'Unknown')
+        year = nearest_meteor.get('year', 'Unknown year')
+        mass = nearest_meteor.get('mass', 'Unknown mass')
+        recclass = nearest_meteor.get('recclass', 'Unknown classification')
+        
+        return (
+            f"Nearest meteor to {location_data['formatted_address']}:\n"
+            f"Name: {name}\n"
+            f"Year: {year}\n"
+            f"Classification: {recclass}\n"
+            f"Mass (grams): {mass}\n"
+            f"Distance: {min_distance:.2f} km\n"
+            f"Coordinates: {nearest_meteor['geolocation']['latitude']}, {nearest_meteor['geolocation']['longitude']}"
+        )
+    else:
+        return "No meteor landing sites found with valid coordinates."
 @tool
 def get_current_time_in_timezone(timezone: str) -> str:
     """A tool that fetches the current local time in a specified timezone.