Spaces:
Runtime error
Runtime error
import gradio as gr | |
import pandas as pd | |
import numpy as np | |
import random | |
import time | |
import os | |
from openai import OpenAI | |
from dotenv import load_dotenv | |
import requests | |
from PIL import Image | |
# load_dotenv("saathi.env") | |
client = OpenAI(api_key=os.environ["OPENAI_API_KEY"]) | |
def put_df2use(html): | |
df = pd.read_html(html)[0] | |
return df | |
def make_msg_chunk_ai(history,team_dropdown,all_teams_df,batting_team,batting_score,chase): | |
#hit flask here for system message with flag | |
req_params = {'flag':os.environ.get("FLAG")} | |
url = os.environ["FLASK_AI_PROMPT"] | |
response = requests.post(url, json=req_params) | |
full_data = response.json() | |
system_message=full_data['ai_data'] | |
print("Got Ai Data : ",system_message,"\n====SYSTEM MESSAGE") | |
temp_df = all_teams_df[all_teams_df["team_id"]==team_dropdown] | |
temp_df = temp_df.drop(["team_id","player_code"],axis=1) | |
cur_tem_selection = temp_df[["player_name","role_type","team"]] | |
updated_system_message = system_message + f"\n Here is the senario by user \n First Batting team ->{batting_team} \n Batting Score ->{batting_score} \n Chase by second Team -> {chase} \n\n *Fantasy Team Selected By User : \n\n {cur_tem_selection.to_string(index=False)}\n\n--" | |
ai_msg = [{"role": "system", "content": updated_system_message}] | |
for chat in history: | |
user_m,bot_m=chat | |
if user_m: | |
val = {"role": "user", "content": user_m} | |
ai_msg.append(val) | |
if bot_m: | |
val = {"role": "assistant", "content": bot_m} | |
ai_msg.append(val) | |
return ai_msg | |
def user(user_message, history): | |
return "", history + [[user_message, None]] | |
def bot(history,team_dropdown,all_teams_df,batting_team,batting_score,chase): | |
print(len(history),"====This is history") | |
bot_templete = make_msg_chunk_ai(history,team_dropdown,all_teams_df,batting_team,batting_score,chase) | |
print("Made bot templete") | |
stream = client.chat.completions.create( | |
model="gpt-4-1106-preview", | |
messages=bot_templete, | |
stream=True) | |
history[-1][1] = "" | |
for chunk in stream: | |
if chunk.choices[0].delta.content is not None: | |
history[-1][1]+=chunk.choices[0].delta.content | |
time.sleep(0.09) | |
print(history) | |
yield history | |
def save_like_data(like_data: gr.LikeData): | |
print(like_data.liked,like_data.value,like_data.index) | |
def activate_chat(chat,user_btn,clear_btn): | |
return gr.update(visible=True),gr.update(visible=True),gr.update(visible=True) | |
def activate_full_builder_and_load_data(email): | |
#batting_score,chase,submit | |
if len(str(email))<5: | |
gr.Warning("Please Enter Valid Email") | |
return gr.update(visible=False),gr.update(visible=False),gr.update(visible=False),gr.update(visible=False),gr.update(visible=True),gr.update(visible=True) | |
request_params = {"email":email,"flag":os.environ.get("FLAG")} | |
url = os.environ["FLASK_API_ACCESS"] | |
response = requests.post(url, json=request_params) | |
batting_choices = response.json().get("teams") | |
print(batting_choices,"response from flask") | |
return gr.update(choices=batting_choices,visible=True),gr.update(visible=True),gr.update(visible=True),gr.update(visible=True),gr.update(visible=False),gr.update(visible=False) | |
team_name_and_team_comp_dict={} | |
def display_generated_teams_df(df): | |
# Create a pivot table counting the number of players by team and team_id | |
pivot_df = pd.pivot_table(df, index='team_id', columns='team', aggfunc='size', fill_value=0) | |
# Reset index to make 'team_id' a column again and ensure a consistent DataFrame structure | |
pivot_df = pivot_df.reset_index() | |
# Renaming the columns if needed, for instance, to map internal team names to display names | |
# This can be skipped or adjusted based on your specific naming requirements | |
# Example: pivot_df.columns = ['Team No', 'PKBS', 'RCB'] | |
# Adjust 'team_id' column name to 'Team No' | |
pivot_df.rename(columns={'team_id': 'Team No'}, inplace=True) | |
pivot_df["sorter"]=pivot_df['Team No'].apply(lambda x: eval(x.lower().replace("team","").strip())) | |
pivot_df = pivot_df.sort_values(["sorter"]) | |
pivot_df.drop(["sorter"],inplace=True,axis=1) | |
return pivot_df | |
def sort_dataframe_by_role(df): | |
""" | |
Sorts the DataFrame by the 'Role' column according to a custom order. | |
Parameters: | |
- df: The DataFrame to be sorted. | |
- role_order: A list specifying the order in which roles should be sorted. | |
Returns: | |
- A DataFrame sorted by the 'Role' column according to the specified order. | |
""" | |
role_order=["Wicket-keeper", "Batsman", "All-rounder", "Bowler"] | |
df['Role'] = pd.Categorical(df['Role'], categories=role_order, ordered=True) | |
sorted_df = df.sort_values('Role') | |
return sorted_df | |
def get_teams_data(batting_team,batting_score,chase): | |
# print(batting_team,"bat team",batting_score,"nan score",chase) | |
if batting_team and batting_score and chase and len(batting_team)>0 and len(batting_score)>0 and len(chase)>0: | |
batting_score=batting_score.split("(")[0].strip() | |
req_params = {'batting_team':batting_team, | |
'batting_score':batting_score, | |
'chase':chase, | |
'flag':os.environ.get("FLAG")} | |
url = os.environ["FLASK_TEAM_BUILDER"] | |
gr.Warning("Making Teams") | |
response = requests.post(url, json=req_params) | |
full_data = response.json() | |
full_data=full_data['teams_generated'] | |
team_name_and_team_comp_dict={} | |
all_teams_df =[] | |
for idx,team in enumerate(full_data): | |
team_name_and_team_comp_dict[f"Team {idx+1}"]=team | |
team = pd.DataFrame(team) | |
team = team.drop_duplicates(["player_code"],ignore_index=True) | |
team["team_id"]=f"Team {idx+1}" | |
team["hit"]=team["hit"].apply(lambda x: round(float(x),1)) | |
all_teams_df.append(team) | |
all_teams_df = pd.concat(all_teams_df) | |
display_teams_df = display_generated_teams_df(all_teams_df) | |
all_team_name = list(team_name_and_team_comp_dict.keys()) | |
first_df = pd.DataFrame(team_name_and_team_comp_dict[all_team_name[0]]) | |
first_df=first_df[["player_name","role_type","team","hit"]] | |
first_df.columns = ["Player Name","Role","Team","HIT%"] | |
first_df = sort_dataframe_by_role(first_df) | |
first_html = first_df.to_html(classes='ui celled table', index=False) | |
return gr.update(choices=all_team_name,value=all_team_name[0],visible=True,interactive=True),gr.update(value=first_html,visible=True),gr.update(visible=True),gr.update(visible=True),all_teams_df,gr.update(value=display_teams_df,visible=True) | |
else: | |
gr.Warning("Please Verify Inputs") | |
# return gr.update(visible=False,interactive=True),gr.update(visible=False),gr.update(visible=False),gr.update(visible=False),pd.DataFrame() | |
return None | |
def pivot_role_team_with_team_names(df): | |
# Copying the original dataframe to not alter it | |
df_copy = df.copy() | |
# Defining the order for the role_type | |
role_order = ["Wicket-keeper", "Batsman", "All-rounder", "Bowler"] | |
# Pivoting the dataframe | |
pivot_df = df_copy.pivot_table(index='role_type', columns='team', aggfunc='size', fill_value=0) | |
# Reindex the pivot table to ensure the order of role_types | |
pivot_df = pivot_df.reindex(role_order) | |
# Adding a total row | |
pivot_df.loc['Total', :] = pivot_df.sum() | |
# Resetting index to make 'role_type' a column instead of an index and renaming it for clarity | |
pivot_df.reset_index(inplace=True) | |
pivot_df.rename(columns={'role_type': 'Role'}, inplace=True) | |
pivot_df.rename_axis(None, axis=1, inplace=True) | |
return pivot_df | |
def fix_hit(hit): | |
try: | |
hit = float(hit) | |
hit = round(hit,1) | |
except Exception as e: | |
hit = "" | |
return hit | |
def display_selected_df(team_index,all_teams_df): | |
temp_df = all_teams_df[all_teams_df["team_id"]==team_index] | |
temp_df = temp_df.drop(["team_id","player_code"],axis=1) | |
temp_df2 = temp_df[["player_name","role_type","team","hit"]] | |
temp_df = temp_df[["player_name","role_type","team"]] | |
disp_df = pivot_role_team_with_team_names(temp_df) | |
temp_df2["hit"]=temp_df2["hit"].apply(fix_hit) | |
temp_df2.columns=["Player Name","Role","Team","HIT%"] | |
# html_header = f"<h2>{team_index}</h2>" | |
temp_df2 = sort_dataframe_by_role(temp_df2) | |
req_html= temp_df2.to_html(classes='ui celled table', index=False) | |
print("changing data") | |
return req_html,disp_df | |
intro_html='''<h3> Welcome to AI-Saathi </h3> | |
<p>Saare fantasy problems ka solution</p> | |
''' | |
with gr.Blocks(theme=gr.themes.Default(primary_hue="amber", secondary_hue="pink")) as demo: | |
# gr.HTML(intro_html) | |
logo = Image.open("assets/IMG_0453.jpg") | |
gr.Image(logo) | |
with gr.Row(): | |
email_input = gr.Textbox(label="Email ID",placeholder="Enter Email for access. Querries : www.apnacricketteam.com",lines=1) | |
with gr.Row(): | |
activation_btn=gr.Button("Load Team Data") | |
with gr.Row(): | |
batting_team = gr.Radio(choices=[], label="Which team will bat 1st?",visible=False,interactive=True) | |
batting_score = gr.Radio(choices=["Low (1st innings < 145)", "Average (1st innings 145-180)", "High (1st innings >180)"],label="What will be 1st innings score?",visible=False,interactive=True) | |
chase = gr.Radio(choices=["Yes", "No"], label="Will it be chased?",visible=False,interactive=True) | |
all_teams_df = gr.DataFrame(visible=False) | |
with gr.Row(): | |
submit = gr.Button("Submit",visible=False) | |
with gr.Row(): | |
teams_info_disp=gr.DataFrame(visible=False,height=300) | |
with gr.Row(): | |
team_dropdown = gr.Dropdown(label="Select Team",allow_custom_value=False,multiselect=False,visible=False) | |
with gr.Row(): | |
html_data = gr.HTML(visible=False) | |
with gr.Row(): | |
basic_status = gr.DataFrame(label="Team Stats",visible=False) | |
with gr.Row(): | |
btn = gr.Button("Team improvement with AI-Saathi",visible=False) | |
curr_team_data=gr.DataFrame(visible=False,interactive=False) | |
with gr.Row(): | |
chat_bot = gr.Chatbot(visible=False) | |
thread_id = gr.Textbox(value="THIS IS THE THREAD-ID",visible=False) | |
with gr.Row(): | |
user_msg = gr.Textbox(placeholder="Team ko change ya improve karne ke liye suggestion le",visible=False) | |
with gr.Row(): | |
clear_btn = gr.ClearButton(chat_bot,visible=False) | |
activation_btn.click(fn=activate_full_builder_and_load_data,inputs=[email_input,],outputs=[batting_team,batting_score,chase,submit,email_input,activation_btn]) | |
submit.click(fn=get_teams_data,inputs=[batting_team,batting_score,chase],outputs=[team_dropdown,html_data,basic_status,btn,all_teams_df,teams_info_disp]) | |
team_dropdown.change(fn=display_selected_df, inputs=[team_dropdown,all_teams_df], outputs=[html_data,basic_status]) | |
# html_data.change(fn=put_df2use,inputs=html_data,outputs=curr_team_data) | |
btn.click(fn=activate_chat,inputs=[chat_bot,user_msg,clear_btn],outputs=[chat_bot,user_msg,clear_btn]) | |
user_msg.submit(user, [user_msg, chat_bot], [user_msg, chat_bot], queue=True).then( | |
bot, [chat_bot,team_dropdown,all_teams_df,batting_team,batting_score,chase], chat_bot) | |
clear_btn.click(lambda: None, None, chat_bot, queue=False) | |
team_dropdown.change(lambda: None, None,chat_bot) | |
team_dropdown.change(lambda: None, None,thread_id) | |
chat_bot.like(fn=save_like_data) | |
demo.queue(default_concurrency_limit=3) | |
demo.launch(share=True) | |