app.py

import gradio as gr
from data_loader import load_data, CATEGORIES, INSIGHTS, METHODOLOGY, TITLE
from utils import model_info_tab, filter_leaderboard
from visualization import setup_matplotlib


def create_app():
    setup_matplotlib()
    df = load_data()

    with gr.Blocks(theme=gr.themes.Soft()) as app:
        with gr.Tabs():
            with gr.Tab("Leaderboard"):
                with gr.Row():
                    with gr.Column(scale=1):
                        gr.Markdown("# Filters")
                        model_type = gr.Dropdown(
                            choices=["All"] + df["Model Type"].unique().tolist(),
                            value="All",
                            label="Model Type",
                        )
                        category = gr.Dropdown(
                            choices=list(CATEGORIES.keys()),
                            value=list(CATEGORIES.keys())[0],
                            label="Category",
                        )
                        sort_by = gr.Radio(
                            choices=["Performance", "Cost"],
                            value="Performance",
                            label="Sort by",
                        )

                    with gr.Column(scale=4):
                        gr.Markdown(TITLE)
                        output = gr.HTML()
                        plot1 = gr.Plot()
                        plot2 = gr.Plot()

                for input_comp in [model_type, category, sort_by]:
                    input_comp.change(
                        fn=lambda m, c, s: filter_leaderboard(df, m, c, s),
                        inputs=[model_type, category, sort_by],
                        outputs=[output, plot1, plot2],
                    )

            with gr.Tab("Model Performance"):
                with gr.Row():
                    with gr.Column(scale=1):
                        model_selector = gr.Dropdown(
                            choices=df["Model"].unique().tolist(),
                            value=df.sort_values("Model Avg", ascending=False).iloc[0][
                                "Model"
                            ],
                            multiselect=True,
                            label="Models",
                        )
                    with gr.Column(scale=4):
                        model_info = gr.HTML()
                        radar_plot = gr.Plot()

                model_selector.change(
                    fn=lambda m: model_info_tab(df, m),
                    inputs=[model_selector],
                    outputs=[model_info, radar_plot],
                )

            with gr.Tab("Methodology"):
                gr.Markdown(METHODOLOGY)

            with gr.Tab("Insights"):
                gr.Markdown(INSIGHTS)

        app.load(
            fn=lambda: filter_leaderboard(
                df, "All", list(CATEGORIES.keys())[0], "Performance"
            ),
            outputs=[output, plot1, plot2],
        )

        app.load(
            fn=lambda: model_info_tab(
                df, [df.sort_values("Model Avg", ascending=False).iloc[0]["Model"]]
            ),
            outputs=[model_info, radar_plot],
        )

    return app


# main.py
if __name__ == "__main__":
    demo = create_app()
    demo.launch()