app.py

from smolagents import CodeAgent,DuckDuckGoSearchTool, HfApiModel,load_tool,tool
import datetime
import requests
import pytz
import yaml
from tools.final_answer import FinalAnswerTool

from Gradio_UI import GradioUI

@tool
def get_pl_team_stats(pl_team_name: str = "Liverpool", season: str = "2023-24") -> dict:
    """Fetches PL team latest Premier League statistics including:
    - Average points
    - Home/Away performance
    - Performance against different table tiers
    
    Args:
        pl_team_name: The Premier League football club's team name
        season: The Premier League season to analyze (format: YYYY-YY)
    
    Returns:
        Dictionary containing comprehensive PL team statistics
    """
    try:
        # First fetch current standings to determine team tiers
        standings_url = "https://fantasy.premierleague.com/api/bootstrap-static/"
        response = requests.get(standings_url)
        response.raise_for_status()
        data = response.json()
        
        # Get team IDs and positions
        teams = {team['id']: team['name'] for team in data['teams']}
        standings = {team['name']: team['position'] for team in data['teams']}
        
        # Determine table tiers
        top6 = [name for name, pos in standings.items() if pos <= 6]
        middle = [name for name, pos in standings.items() if 7 <= pos <= 14]
        bottom6 = [name for name, pos in standings.items() if pos >= 15]
        
        # Now fetch team's fixtures
        team_id = [id for id, name in teams.items() if pl_team_name in name][0]
        fixtures_url = f"https://fantasy.premierleague.com/api/team/{team_id}/fixtures/"
        response = requests.get(fixtures_url)
        response.raise_for_status()
        fixtures = response.json()
        
        # Filter for completed matches in specified season
        completed_matches = [
            f for f in fixtures 
            if f['finished'] and f['season_name'] == season
        ]
        
        # Initialize stats
        stats = {
            'total_matches': len(completed_matches),
            'total_points': 0,
            'home': {'matches': 0, 'points': 0},
            'away': {'matches': 0, 'points': 0},
            'vs_top6': {'matches': 0, 'points': 0},
            'vs_middle': {'matches': 0, 'points': 0},
            'vs_bottom6': {'matches': 0, 'points': 0}
        }
        
        # Process each match
        for match in completed_matches:
            # Calculate points (3 for win, 1 for draw)
            if match['team_h_score'] > match['team_a_score']:
                points = 3 if match['team_h'] == team_id else 0
            elif match['team_h_score'] == match['team_a_score']:
                points = 1
            else:
                points = 3 if match['team_a'] == team_id else 0
            
            stats['total_points'] += points
            
            # Home/away stats
            if match['team_h'] == team_id:
                stats['home']['matches'] += 1
                stats['home']['points'] += points
                opponent = teams[match['team_a']]
            else:
                stats['away']['matches'] += 1
                stats['away']['points'] += points
                opponent = teams[match['team_h']]
            
            # Opposition tier stats
            if opponent in top6:
                stats['vs_top6']['matches'] += 1
                stats['vs_top6']['points'] += points
            elif opponent in middle:
                stats['vs_middle']['matches'] += 1
                stats['vs_middle']['points'] += points
            elif opponent in bottom6:
                stats['vs_bottom6']['matches'] += 1
                stats['vs_bottom6']['points'] += points
        
        # Calculate averages
        def safe_divide(a, b):
            return round(a/b, 2) if b > 0 else 0.0
            
        stats['avg_points'] = safe_divide(stats['total_points'], stats['total_matches'])
        stats['home']['avg_points'] = safe_divide(stats['home']['points'], stats['home']['matches'])
        stats['away']['avg_points'] = safe_divide(stats['away']['points'], stats['away']['matches'])
        stats['vs_top6']['avg_points'] = safe_divide(stats['vs_top6']['points'], stats['vs_top6']['matches'])
        stats['vs_middle']['avg_points'] = safe_divide(stats['vs_middle']['points'], stats['vs_middle']['matches'])
        stats['vs_bottom6']['avg_points'] = safe_divide(stats['vs_bottom6']['points'], stats['vs_bottom6']['matches'])
        
        return stats
    
    except Exception as e:
        return {"error": f"Failed to fetch team stats: {str(e)}"}

# # Add the tool to your agent
# agent = CodeAgent(
#     model=model,
#     tools=[final_answer, image_generation_tool, get_pl_team_stats],  # Added our new tool
#     max_steps=6,
#     verbosity_level=1,
#     grammar=None,
#     planning_interval=None,
#     name=None,
#     description=None,
#     prompt_templates=prompt_templates
# )

@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').
    """
    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
model_id='https://pflgm2locj2t89co.us-east-1.aws.endpoints.huggingface.cloud',
custom_role_conversions=None,
)


# Import tool from Hub
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, image_generation_tool, get_pl_team_stats], ## add your tools here (don't remove final answer)
    max_steps=6,
    verbosity_level=1,
    grammar=None,
    planning_interval=None,
    name=None,
    description=None,
    prompt_templates=prompt_templates
)


GradioUI(agent).launch()