init commit

app.py

@@ -6,6 +6,8 @@ import yaml
 from tools.final_answer import FinalAnswerTool
 
 from Gradio_UI import GradioUI
+from tools.star_in_my_sky import get_star_visibility
+
 
 # Below is an example of a tool that does nothing. Amaze us with your creativity !
 @tool
@@ -18,6 +20,19 @@ def my_custom_tool(arg1:str, arg2:int)-> str: #it's import to specify the return
     """
     return "What magic will you build ?"
 
+@tool
+def is_star_in_my_sky(star_name: str, location_name: str) -> str:
+    """A tool that checks if a star is currently visible in the sky at a given location.
+    Args:
+        star_name: The name of the star to check.
+        location_name: The location to check. e.g. London, UK
+    """
+    try:
+        resp = get_star_visibility(star_name, location_name)
+    except Exception as e:
+        return f"Error: {str(e)}"
+    return resp
+
 @tool
 def get_current_time_in_timezone(timezone: str) -> str:
     """A tool that fetches the current local time in a specified timezone.
@@ -48,14 +63,14 @@ custom_role_conversions=None,
 
 
 # Import tool from Hub
-image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
+# image_generation_tool = load_tool("agents-course/text-to-image", trust_remote_code=True)
 
 with open("prompts.yaml", 'r') as stream:
     prompt_templates = yaml.safe_load(stream)
     
 agent = CodeAgent(
     model=model,
-    tools=[final_answer], ## add your tools here (don't remove final answer)
+    tools=[final_answer, is_star_in_my_sky], ## add your tools here (don't remove final answer)
     max_steps=6,
     verbosity_level=1,
     grammar=None,

tools/star_in_my_sky.py

@@ -0,0 +1,96 @@
+from astroquery.simbad import Simbad
+from astropy.coordinates import SkyCoord
+from astropy import units as u
+
+from geopy.geocoders import Nominatim
+
+from skyfield.api import load, Topos, Star
+from smolagents import Tool
+
+# Make sure RA/DEC fields are included in SIMBAD query
+Simbad.add_votable_fields("ra", "dec")
+
+class StarInMySkyTool(Tool):
+    name = "star_in_my_sky"
+    description = (
+        "Checks if a star is currently visible in the sky at a given location."
+        "This tool expects two arguments: the name of the star and the location in English."
+    )
+    inputs = {
+        "star_name": {"type": "string", "description": "The name of the star to check."},
+        "location_name": {"type": "string", "description": "The location to check. e.g. London, UK"},
+    }
+    output_type = "string"
+
+    def forward(self, star_name: str, location_name: str) -> str:
+        try:
+            resp = get_star_visibility(star_name, location_name)
+        except Exception as e:
+            return f"Error: {str(e)}"
+        return resp
+
+def get_coordinates_from_location(location_name):
+    """Use geopy to convert a place name into latitude/longitude."""
+    geolocator = Nominatim(user_agent="astrogeo")
+    location = geolocator.geocode(location_name)
+    if not location:
+        raise ValueError(f"Could not geocode location: {location_name}")
+    return location.latitude, location.longitude
+
+
+def get_star_visibility(star_name, location_name):
+    """
+    1. Convert a location name to lat/long.
+    2. Query SIMBAD for star's RA/Dec.
+    3. Compute altitude/azimuth via Skyfield.
+    4. Print whether the star is above or below the horizon.
+    """
+    # 1. Get lat/long from location name
+    latitude, longitude = get_coordinates_from_location(location_name)
+    print(f"Location '{location_name}': lat={latitude:.4f}, lon={longitude:.4f}")
+
+    # 2. Query SIMBAD for the star's RA/DEC
+    result_table = Simbad.query_object(star_name)
+    if result_table is None:
+        print(f"Could not find star '{star_name}' in SIMBAD.")
+        return
+
+    if "ra" not in result_table.colnames or "dec" not in result_table.colnames:
+        print("The 'ra'/'dec' columns are missing in SIMBAD’s response!")
+        return
+
+    ra_str = result_table["ra"][0]  # e.g. '06 45 08.92'
+    dec_str = result_table["dec"][0]  # e.g. '-16 42 58.0'
+
+    # Convert RA/DEC to numeric values using Astropy
+    skycoord = SkyCoord(ra_str, dec_str, unit=(u.hourangle, u.deg))
+
+    # 3. Create a Skyfield Star object
+    star = Star(ra_hours=skycoord.ra.hour, dec_degrees=skycoord.dec.degree)
+
+    # 4. Load ephemeris, define observer, compute alt/az for now
+    ts = load.timescale()
+    t = ts.now()
+
+    planets = load("de421.bsp")
+    earth = planets["earth"]
+    observer = Topos(latitude_degrees=latitude, longitude_degrees=longitude)
+
+    # Calculate altitude, azimuth
+    alt, az, distance = (earth + observer).at(t).observe(star).apparent().altaz()
+
+    resp = ""
+    # 5. Print results
+    if alt.degrees > 0:
+        resp = f"""
+Star '{star_name}' is above the horizon at {location_name} (NOW).
+Altitude: {alt.degrees:.2f}°, Azimuth: {az.degrees:.2f}°
+        """
+    else:
+        resp = f"\nStar '{star_name}' is below the horizon at {location_name} (NOW)."
+    return resp
+
+
+if __name__ == "__main__":
+    # Example: London
+    get_star_visibility("Sirius", "London, UK")

tools/visit_webpage.py

@@ -1,45 +0,0 @@
-from typing import Any, Optional
-from smolagents.tools import Tool
-import requests
-import markdownify
-import smolagents
-
-class VisitWebpageTool(Tool):
-    name = "visit_webpage"
-    description = "Visits a webpage at the given url and reads its content as a markdown string. Use this to browse webpages."
-    inputs = {'url': {'type': 'string', 'description': 'The url of the webpage to visit.'}}
-    output_type = "string"
-
-    def forward(self, url: str) -> str:
-        try:
-            import requests
-            from markdownify import markdownify
-            from requests.exceptions import RequestException
-
-            from smolagents.utils import truncate_content
-        except ImportError as e:
-            raise ImportError(
-                "You must install packages `markdownify` and `requests` to run this tool: for instance run `pip install markdownify requests`."
-            ) from e
-        try:
-            # Send a GET request to the URL with a 20-second timeout
-            response = requests.get(url, timeout=20)
-            response.raise_for_status()  # Raise an exception for bad status codes
-
-            # Convert the HTML content to Markdown
-            markdown_content = markdownify(response.text).strip()
-
-            # Remove multiple line breaks
-            markdown_content = re.sub(r"\n{3,}", "\n\n", markdown_content)
-
-            return truncate_content(markdown_content, 10000)
-
-        except requests.exceptions.Timeout:
-            return "The request timed out. Please try again later or check the URL."
-        except RequestException as e:
-            return f"Error fetching the webpage: {str(e)}"
-        except Exception as e:
-            return f"An unexpected error occurred: {str(e)}"
-
-    def __init__(self, *args, **kwargs):
-        self.is_initialized = False