app.py

from smolagents import CodeAgent,DuckDuckGoSearchTool, WebSearchTool, HfApiModel,load_tool,tool
import datetime
import requests
import pytz
import yaml
from tools.final_answer import FinalAnswerTool
from ip2geotools.databases.noncommercial import DbIpCity
from bs4 import BeautifulSoup
import urllib as ur
import tkinter as tk
from tkinter.messagebox import *
import json
from PIL import ImageTk

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 
    Args:
        arg1: the first argument
        arg2: the second argument
"""
# return 

@tool
def get_location_tool(ip: str): str

    return {
            'city': response.city,
            'region': response.region,
            'country': response.country,
            'latitude': response.latitude,
            'longitude': response.longitude
           }

"""This is a tool that gets the exact location of a user including city, region, country, latitude, and longitude.
    Args: 
        ip: A string representing a valid ip address (e.g., '192.168.10.1')

    Args:
        city: A string representing a valid city (e.g., 'Dubai, Singapore')

    Args:
        region: A string representing a valid region (e.g, 'Africa, Asia')

    Args:
        country: A string representing a valid country (e.g., 'Ethiopia, United Arab Emirates')

    Args:
        latitude: A string representing valid latitude coordinates (e.g., '40.741895')

    Args:
        longitude: A string representing valid longitude coordinates (e.g, '73.989308')

    Returns: ip address, city, region, country, and geo coordinates
"""
        
response = DbIpCity.get(ip, api_key='free')


ip_address = 'YOUR_IP_ADDRESS'  # Replace with the actual IP address
location = get_location(ip_address)
print(location)


@tool
def get_current_time_in_timezone(timezone: str): str
    
"""A tool that fetches the current local time in a specified timezone.
    Args:
        timezone: A string representing a valid timezone (e.g., 'America/New_York')

    Returns: The current local time in the following format ("%Y-%m-%d %H:%M:%S")
"""
try:
        # Create timezone object
        tz = pytz.timezone(timezone)
        
    # Get current time in that timezone
        local_time = datetime.datetime.now(tz).strftime("%Y-%m-%d %H:%M:%S")
        return f"The current local time in {timezone} is: {local_time}"
except Exception as e:
    
    return f"Error fetching time for timezone '{timezone}': {str(e)}"


final_answer = FinalAnswerTool()

# If the agent does not answer, the model is overloaded, please use another model or the following Hugging Face Endpoint that also contains qwen2.5 coder:
# model_id='https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud' 

model = HfApiModel(
max_tokens=2096,
temperature=0.5,
model_id='Qwen/Qwen2.5-Coder-32B-Instruct',# it is possible that this model may be overloaded
custom_role_conversions=None,
)

@tool
def get_weather_data(city: str):
    
    """
    Returns weather data for a given city.
    Args:
        city: The name of the city (e.g., New York, London, Tokyo)
    Returns:
        A dictionary containing weather data
    """
    # Get weather for multiple cities
cities = ["Tokyo", "New York", "London"]
data = {}

for city in cities:
    data[city] = get_weather_data(city)
# Calculate average temperatures
avg_temps = {city: sum(info["temperatures"])/len(info["temperatures"]) 
             for city, info in data.items()}
# Find the warmest city
warmest_city = max(avg_temps, key=avg_temps.get)
print(f"The warmest city is {warmest_city} with an average of {avg_temps[warmest_city]:.1f}°C")

@tool
def hotel_recommendation_tool(city: str,price: str): str
"""This is a hotel recommendation tool that web scrapes foursquare.com, and yelp.com for hotel ratings, user comments, and hotel information.
        Args:
             city: A string representing a valid city (e.g., 'Dubai, Singapore')
        Args:
            price: A string representing a valid price for the hotel rooms (e.g., '$160/night, $100/day')

        Returns: A hotel name in a particular city with its pricing, and rating information
"""
    
if(price!="-"):
        response=ur.request.urlopen('https://foursquare.com/explore?mode=url&near='+city+'&price='+price+'&q=Resturant')
else:
        response=ur.request.urlopen('https://foursquare.com/explore?mode=url&near='+city+'&q=Resturant')
        html=response.read()
        soup=BeautifulSoup(html,'html.parser')
        name=[]
        rate=[]
        add=[]
        y="""<li class="card singleRecommendation hasPhoto"""
        for link in soup.find_all('li'):
            if (y in str(link)):
                name.append(link.find('div',{"class":"venueName"}))
            if(link.find('div',{"class":"venueScore positive"})!=None):
                rate.append(link.find('div',{"class":"venueScorepositive"}))
            elif(link.find('div',{"class":"venueScoreneutral"})!=None):
                rate.append(link.find('div',{"class":"venueScoreneutral"}))
            else:
                rate.append(link.find('div',{"class":"venueScoreunknown"}))
                                                  
        rate1=[]
        for x in rate:
            if(x!=None):
                rate1.append(x.string.encode("utf-8"))
        else:
            rate1.append("?")

    ##print(rate1)

        name1=[]
        for x in name:
            name1.append(x.a.string.encode("utf-8"))
        
            name_rate=[]
        for i in range(0,len(name1)):
            name_rate.append((name1[i],rate1[i]))
    
return name_rate


              
def yelp(city,price):
    name_rate=[]
    count=0
    while(count<30):
        if(price!="-"):
            response=ur.request.urlopen('https://www.yelp.com/search?find_desc=Restaurants&find_loc='+city+'&start='+str(count)+'&ed_attrs=RestaurantsPriceRange2.'+price)
        else:
            response=ur.request.urlopen('https://www.yelp.com/search?find_desc=Restaurants&find_loc='+city+'&start='+str(count))
            
        html=response.read()
        count+=10
        soup=BeautifulSoup(html,'html.parser')
        
        y="""<li class="regular-search-result">"""
        name=[]
        rate=[]
        name1=[]
        rate1=[]
        for link in soup.find_all('li'):
            if (y in str(link)):
                name.append(link.find('span',{"class":"indexed-bizname"}))
                rate.append(link.find('img',{"class":"offscreen"}))
        for i in name:
            name1.append(i.span.string.encode("utf-8"))
            
        for i in rate:
            try:
                s=str(i['alt'])
                rate1.append(float(s[0:3]))
            except:
                rate1.append("?")
        for i in range(0,len(name1)):
            name_rate.append((name1[i],rate1[i]))
        
    return name_rate
    


root=tk.Tk()
root.geometry("645x660")
root.configure(bg='#211C5F')
root.title("Scraping Recommender")
def locate():
    send_url = 'http://freegeoip.net/json'
    r = requests.get(send_url)
    j = json.loads(r.text)
    lat = j['latitude']
    lon = j['longitude']
    e1.delete(0,tk.END)
    city=str(lat)+" "+str(lon)
    e1.insert(tk.END,"Current Location")
    return city


def get():
    city=e1.get()
    if(city=="Current Location"):
        city=locate()
    price=e2.get()
    if city=="":
        showerror(title="Empty Field",message="Please Enter a City!")
        return
    l=["1","2","3","4","-"]
    if price not in l:
        showerror(title="Please Wait",message="Please Enter Correct Price Range!")
        return

@tool
def SearchTool(DuckDuckGoSearchTool): query
    
"""
    name = "web_search"
    description = "Performs a web search for a query and returns a list of the top search results formatted as markdown with page titles and urls."
    inputs = {"query": {"type": "string", "description": "The search query to perform."}}
    output_type = "string"
"""

search_tool = DuckDuckGoSearchTool()
agent = CodeAgent(tools=[search_tool], model=model, add_base_tools=False, verbosity_level=2)


GradioUI(agent).launch()