Basic backend setup with FastApi but without actual filtering

evals/app.py

@@ -1,993 +0,0 @@
-import json
-from functools import partial
-
-import gradio as gr
-import pandas as pd
-import plotly.express as px
-import plotly.graph_objects as go
-import pycountry
-from gradio_rangeslider import RangeSlider
-from tqdm import tqdm
-
-with open("results.json") as f:
-    languages = json.load(f) 
-
-languages_with_scores = [lang for lang in languages if lang["t2t_score"] is not None]
-
-# Global constants for metric mappings
-METRICS = {
-    "t2t": [
-        {
-            "display_name": "Overall Text-to-Text Performance",
-            "field_name": "t2t_score",
-            "label": "Overall Score",
-            "explanation": """
-    **Overall Score for Text-to-Text Performance**: A weighted combination of all metrics, providing a holistic view of model performance across different language tasks. 
-    Higher scores indicate better overall language capabilities.
-    """,
-        },
-        {
-            "display_name": "Translation (BLEU)",
-            "field_name": "mt_bleu",
-            "label": "BLEU Score",
-            "explanation": """
-    **Translation BLEU**: BiLingual Evaluation Understudy (BLEU) measures how similar AI-generated translations are to human reference translations.
-    It calculates n-gram precision and applies a brevity penalty. Scores range from 0 to 1, with higher values indicating better translation quality.
-    """,
-        },
-        {
-            "display_name": "Translation (ChrF)",
-            "field_name": "mt_chrf",
-            "label": "ChrF Score",
-            "explanation": """
-    **Translation ChrF**: Character n-gram F-score evaluates translations at the character level rather than word level.
-    This metric is particularly valuable for morphologically rich languages and can better capture partial word matches.
-    Higher scores (0-1) indicate better translations.
-    """,
-        },
-        {
-            "display_name": "Classification (Accuracy)",
-            "field_name": "cls_acc",
-            "label": "Classification Accuracy",
-            "explanation": """
-    **Classification Accuracy**: Measures how accurately models can classify text into predefined categories.
-    This evaluates a model's understanding of content and context across different languages.
-    Reported as a percentage where higher values indicate better classification performance.
-    """,
-        },
-        {
-            "display_name": "Masked Language Modeling (ChrF)",
-            "field_name": "mlm_chrf",
-            "label": "MLM ChrF Score",
-            "explanation": """
-    **Masked Language Modeling ChrF**: Evaluates how well models can predict masked (hidden) portions of text.
-    This tests a model's understanding of language structure and semantics by measuring the character-level similarity
-    between predicted and actual text. Higher scores indicate better language understanding.
-    """,
-        },
-    ],
-    "s2t": [
-        {
-            "display_name": "Overall Speech-to-Text Performance",
-            "field_name": "s2t_score",
-            "label": "Overall Score",
-            "explanation": """
-    **Overall Score for Speech-to-Text Performance**: A weighted combination of all metrics, providing a holistic view of model performance across different language tasks. 
-    Higher scores indicate better overall language capabilities.
-    """,
-        },
-        {
-            "display_name": "Automatic Speech Recognition (WER)",
-            "field_name": "asr_wer",
-            "label": "WER",
-            "explanation": """ 
-    **Automatic Speech Recognition Word Error Rate**: Measures the accuracy of speech-to-text transcription.
-    It calculates the minimum number of word edits (insertions, deletions, substitutions) needed to transform the 
-    transcription into the reference text, divided by the number of words in the reference.
-    Lower scores indicate better performance, with 0 being perfect transcription.
-    """,
-        },
-        {
-            "display_name": "Automatic Speech Recognition (ChrF)",
-            "field_name": "asr_chrf",
-            "label": "ChrF",
-            "explanation": """
-    **Automatic Speech Recognition ChrF**: Character n-gram F-score evaluates translations at the character level rather than word level.
-    This metric is particularly valuable for morphologically rich languages and can better capture partial word matches.
-    Higher scores (0-1) indicate better translations.
-    """,
-        },
-    ],
-}
-
-
-def mean(lst):
-    return sum(lst) / len(lst)
-
-
-def create_leaderboard_df(model_type, metric=None):
-    metric = metric or METRICS[model_type][0]
-    _model_type = {"t2t": "text-to-text", "s2t": "speech-to-text"}[model_type]
-    models = {
-        score["model"]
-        for lang in languages_with_scores
-        for score in lang["scores"]
-        if score["model_type"] == _model_type
-    }
-    model_scores = [
-        {"model": score["model"], metric["field_name"]: score[metric["field_name"]]}
-        for lang in languages_with_scores
-        for score in lang["scores"]
-        for model in models
-        if score["model"] == model
-    ]
-    df = (
-        pd.DataFrame(model_scores)
-        .groupby("model")
-        .agg({metric["field_name"]: ["mean", "count"]})
-        .reset_index()
-    )
-    # Flatten the multi-level column names
-    df.columns = df.columns.map(
-        lambda x: f"{x[0]}_{x[1]}" if isinstance(x, tuple) else x
-    )
-    df = df.rename(
-        columns={
-            f"{metric['field_name']}_mean": metric["label"],
-            f"{metric['field_name']}_count": "Languages Tested",
-            "model_": "Model",
-        }
-    )
-    df[metric["label"]] = df[metric["label"]].round(3)
-    df = df.sort_values(metric["label"], ascending=False)
-    df["Rank"] = range(1, len(df) + 1)
-    df["Rank"] = df["Rank"].apply(
-        lambda x: "🥇" if x == 1 else "🥈" if x == 2 else "🥉" if x == 3 else str(x)
-    )
-    df = df[["Rank", "Model", metric["label"]]]
-    return gr.DataFrame(
-        value=df,
-        label="Model Leaderboard",
-        show_search=False,
-        datatype=["number", "markdown", "number"],
-    )
-
-
-def create_model_comparison_plot(metric):
-    top_languages = sorted(
-        languages_with_scores, key=lambda x: x["speakers"], reverse=True
-    )[:10]
-
-    # Create appropriate title and y-axis label based on metric
-    title = f"{metric['display_name']} by Model and Language"
-    y_label = metric["label"]
-
-    # Flatten the data for the selected metric
-    scores_flat = []
-    for lang in top_languages:
-        for score in lang["scores"]:
-            # Get the value directly using the field name
-            if metric["field_name"] not in score:
-                continue
-            value = score[metric["field_name"]]
-            if value is not None:
-                scores_flat.append(
-                    {
-                        "language": lang["language_name"],
-                        "model": score["model"],
-                        "value": value,
-                    }
-                )
-
-    df = pd.DataFrame(scores_flat)
-    fig = px.bar(df, x="language", y="value", color="model", barmode="group")
-    fig.update_layout(
-        title=title,
-        xaxis_title=None,
-        yaxis_title=y_label,
-        barmode="group",
-        height=500,
-        legend=dict(
-            orientation="h",  # horizontal orientation
-            yanchor="bottom",
-            y=-0.3,  # position below plot
-            xanchor="center",
-            x=0.5,  # center horizontally
-        ),
-    )
-    return fig
-
-
-def create_language_stats_df(metric):
-    # Create a list to store flattened data
-    flat_data = []
-
-    for lang in languages:
-        # Find the best model and its BLEU score
-        best_model = (
-            max(
-                lang["scores"] or [{"t2t_score": None, "model": None}],
-                key=lambda x: x.get("t2t_score", 0),
-            )
-            if lang["t2t_score"] is not None
-            else None
-        )
-
-        model = best_model["model"] if best_model else None
-        model_name = model.split("/")[-1] if model else "N/A"
-        model_link = (
-            f"<a href='https://openrouter.ai/{model}' style='text-decoration: none; color: inherit;'>{model_name}</a>"
-            if model
-            else "N/A"
-        )
-        commonvoice_link = (
-            f"<!--{lang['commonvoice_hours']:07} (for sorting)--> <a href='https://commonvoice.mozilla.org/{lang['commonvoice_locale']}/speak' style='text-decoration: none; color: inherit;'>🎙️ {round(lang['commonvoice_hours'])}h</a>"
-            if lang["commonvoice_hours"]
-            else "N/A"
-        )
-        language_link = f"<a href='/{lang['bcp_47']}' style='text-decoration: none; font-weight: bold;'>{lang['language_name']}</a>"
-        
-        row = {
-            "Language": language_link,
-            "Speakers (M)": round(lang["speakers"] / 1_000_000, 1),
-            # "Models Tested": len(lang["scores"]),
-            # "Overall": round(lang["overall_score"], 3)
-            # if lang["overall_score"] is not None
-            # else "N/A",
-            "Best Model": model_link,
-            "Trans­la­ti­on": round(lang["mt_chrf"], 3)
-            if lang["mt_chrf"] is not None
-            else "N/A",
-            "Classi­fi­ca­ti­on": round(lang["cls_acc"], 3)
-            if lang["cls_acc"] is not None
-            else "N/A",
-            "Masked Language Modeling": round(lang["mlm_chrf"], 3)
-            if lang["mlm_chrf"] is not None
-            else "N/A",
-            "Speech Reco­gni­ti­on": round(lang["asr_chrf"], 3) if lang["asr_wer"] is not None else "N/A",
-            "Common­Voice": commonvoice_link,
-        }
-        flat_data.append(row)
-
-    df = pd.DataFrame(flat_data)
-    return gr.DataFrame(
-        value=df,
-        label="Language Results",
-        show_search="search",
-        pinned_columns=1,
-        column_widths=[
-            "100px",
-            "100px",
-            # "100px",
-            # "100px",
-            "200px",  # Best Model
-            "100px",  # MT
-            "100px",  # CLS
-            "100px",  # MLM
-            "100px",  # ASR
-            "100px",  # Common Voice
-        ],
-        datatype=[
-            "markdown",  # Language
-            "number",  # Speakers
-            # "number", # Models Tested
-            # "number",  # Overall
-            "markdown",  # Best Model
-            "number",  # Translation
-            "number",  # Classification
-            "number",  # MLM
-            "number",  # ASR
-            "markdown",  # CommonVoice Hours
-        ],
-    )
-
-
-def create_scatter_plot(metric):
-    # Create a list to store data for the scatter plot
-    scatter_data = []
-    for lang in languages_with_scores:
-        if lang["speakers"] < 100_000:
-            continue
-        # Calculate average score for this metric across all models
-        scores = [
-            score[metric["field_name"]]
-            for score in lang["scores"]
-            if metric["field_name"] in score and score[metric["field_name"]] is not None
-        ]
-        if scores:  # Only include if we have valid scores
-            avg_score = sum(scores) / len(scores)
-            scatter_data.append(
-                {
-                    "language": lang["language_name"],
-                    "speakers": lang["speakers"],
-                    "score": avg_score,
-                    "family": lang["language_family"],
-                }
-            )
-
-    fig = go.Figure()
-    x_vals = [data["speakers"] / 1_000_000 for data in scatter_data]
-    y_vals = [data["score"] for data in scatter_data]
-    s_vals = [data["speakers"] / 20_000_000 for data in scatter_data]
-    color_pallette = [
-        "LightSkyBlue",
-        "LightGreen",
-        "LightCoral",
-        "LightPink",
-        "LightGoldenRodYellow",
-        "LightGray",
-        "LightSalmon",
-        "LightSeaGreen",
-    ]
-    color_mapping = {
-        family: color
-        for family, color in zip(
-            sorted(set(data["family"] for data in scatter_data)), color_pallette
-        )
-    }
-    c_vals = [color_mapping.get(data["family"], "LightGray") for data in scatter_data]
-    labels = [data["language"] for data in scatter_data]
-    hover_template = f"<b>%{{text}}</b><br>Speakers: %{{x:.1f}}M<br>{metric['label']}: %{{y:.3f}}<extra></extra>"
-    fig.add_trace(
-        go.Scatter(
-            x=x_vals,
-            y=y_vals,
-            marker=dict(size=s_vals, color=c_vals),
-            mode="markers+text",
-            text=labels,
-            textposition="top center",
-            hovertemplate=hover_template,
-        )
-    )
-    fig.update_layout(
-        title=None,
-        xaxis_title="Number of Speakers (Millions)",
-        yaxis_title=metric["label"],
-        height=500,
-        showlegend=False,
-    )
-    fig.update_xaxes(type="log")
-    return fig
-
-
-def format_number(n):
-    """Format number with K/M suffix"""
-    if n >= 1_000_000:
-        return f"{n/1_000_000:.1f}M"
-    elif n >= 1_000:
-        return f"{n/1_000:.0f}K"
-    return str(n)
-
-
-def get_population_data():
-    import xml.etree.ElementTree as ET
-
-    from language_data.util import data_filename
-
-    filename = data_filename("supplementalData.xml")
-    root = ET.fromstring(open(filename).read())
-    territories = root.findall("./territoryInfo/territory")
-
-    data = {}
-    for territory in territories:
-        t_code = territory.attrib["type"]
-        t_population = float(territory.attrib["population"])
-        data[t_code] = t_population
-    return data
-
-
-# Helper functions for visualization
-def make_black_bar(value, max_width=10):
-    filled = int(value * max_width)
-    return "⬛️" * filled + "⬜️" * (max_width - filled)
-
-
-def make_colored_bar(score, max_width=10):
-    """Create a colored bar using Unicode blocks based on normalized score
-    🟦 for high values (>0.35)
-    🟨 for medium values (0.25-0.35)
-    🟥 for low values (<0.25)
-    ⬜ for empty space
-
-    This function handles both normalization and bar creation.
-    """
-
-    # Create the bar based on normalized value
-    filled = int(score * max_width)
-    filled = max(0, min(filled, max_width))
-    empty = max_width - filled
-
-    if score > 0.35:
-        return "🟦" * filled + "⬜" * empty
-    elif score > 0.25:
-        return "🟨" * filled + "⬜" * empty
-    else:
-        return "🟥" * filled + "⬜" * empty
-
-
-def create_world_map(metric):
-    # Collect all country data
-    population_data = get_population_data()
-    country_data = {}
-    for lang in languages:
-        # Skip languages without the required data
-        if "population" not in lang or lang[metric["field_name"]] is None:
-            continue
-
-        for country_code, speakers in lang["population"].items():
-            try:
-                # Convert alpha_2 (2-letter) to alpha_3 (3-letter) code
-                country = pycountry.countries.get(alpha_2=country_code)
-                if country is None:
-                    continue
-
-                iso3_code = country.alpha_3
-                if iso3_code not in country_data:
-                    country_data[iso3_code] = {
-                        "total_speakers": 0,
-                        "population": population_data.get(country_code, 0),
-                        "weighted_score_sum": 0,
-                        "languages": [],
-                    }
-
-                country_data[iso3_code]["total_speakers"] += speakers
-                country_data[iso3_code]["weighted_score_sum"] += (
-                    speakers * lang[metric["field_name"]]
-                )
-                country_data[iso3_code]["languages"].append(
-                    {
-                        "name": lang["language_name"],
-                        "speakers": speakers,
-                        "score": lang[metric["field_name"]],
-                    }
-                )
-            except (KeyError, AttributeError):
-                # Skip invalid or unrecognized country codes
-                continue
-
-    # Calculate final weighted averages and prepare hover text
-    countries = []
-    scores = []
-    hover_texts = []
-
-    for country_code, data in country_data.items():
-        weighted_avg = data["weighted_score_sum"] / data["total_speakers"] if data["total_speakers"] > 0 else None
-
-        try:
-            country_name = pycountry.countries.get(alpha_3=country_code).name
-        except AttributeError:
-            country_name = country_code
-
-        # Sort languages by number of speakers
-        langs = sorted(data["languages"], key=lambda x: x["speakers"], reverse=True)
-
-        # Take top 5 languages and summarize the rest
-        main_langs = langs[:5]
-        other_langs = langs[5:]
-
-        # Create language rows with bars
-        lang_rows = []
-        for lang in main_langs:
-            percentage = (lang["speakers"] / data["population"]) * 100
-            speaker_bar = make_black_bar(percentage / 100)
-
-            # Use the integrated make_colored_bar function directly
-            score_bar = make_colored_bar(lang["score"])
-
-            lang_rows.append(
-                f"<b>{lang['name']}</b><br>"
-                f"{speaker_bar} {format_number(lang['speakers'])} speakers<br>"
-                f"{score_bar} {lang['score']:.3f} {metric['label']}<br>"
-            )
-
-        # Add summary for other languages if any
-        if other_langs:
-            other_speakers = sum(lang["speakers"] for lang in other_langs)
-            other_percentage = (other_speakers / data["population"]) * 100
-            other_avg_score = sum(lang["score"] for lang in other_langs) / len(
-                other_langs
-            )
-
-            speaker_bar = make_black_bar(other_percentage / 100)
-
-            # Use the integrated make_colored_bar function directly
-            score_bar = make_colored_bar(other_avg_score)
-
-            lang_rows.append(
-                f"<b>+{len(other_langs)} other languages</b><br>"
-                f"{speaker_bar} {format_number(other_speakers)} speakers<br>"
-                f"{score_bar} {other_avg_score:.3f} {metric['label']}<br>"
-            )
-
-        hover_text = f"<b>{country_name}</b><br><br>" f"{'<br>'.join(lang_rows)}"
-
-        countries.append(country_code)
-        scores.append(weighted_avg)
-        hover_texts.append(hover_text)
-
-    fig = go.Figure(
-        data=go.Choropleth(
-            locations=countries,
-            locationmode="ISO-3",
-            z=scores,
-            text=hover_texts,
-            hoverinfo="text",
-            colorscale=[[0, "#ff9999"], [1, "#99ccff"]],
-            colorbar=dict(
-                title=metric["label"],
-                orientation="h",  # horizontal orientation
-                y=-0.2,  # position below map
-                yanchor="bottom",
-                len=0.5,  # length of colorbar
-                x=0.5,  # center horizontally
-                xanchor="center",
-                thickness=20,  # make it a bit thicker when horizontal
-            ),
-        )
-    )
-
-    fig.update_layout(
-        title=dict(
-            text=f"{metric['display_name']} by Country", x=0.5, xanchor="center"
-        ),
-        geo=dict(
-            showframe=True,
-            showcoastlines=True,
-            projection_type="equal earth",
-            showland=True,
-            landcolor="#f8f9fa",
-            coastlinecolor="#e0e0e0",
-            countrycolor="#e0e0e0",
-        ),
-        height=600,
-        margin=dict(l=0, r=0, t=30, b=0),
-        paper_bgcolor="white",
-        hoverlabel=dict(
-            bgcolor="beige",
-            font_size=12,
-        ),
-    )
-
-    return fig
-
-
-def create_metric_selector(model_type):
-    match model_type:
-        case "t2t":
-            choices = [m["display_name"] for m in METRICS["t2t"]]
-        case "s2t":
-            choices = [m["display_name"] for m in METRICS["s2t"]]
-    return gr.Dropdown(
-        choices=choices, value=choices[0], label="Select Metric", interactive=True
-    )
-
-
-def create_metric_explanation(metric):
-    return gr.Markdown(metric["explanation"], container=True)
-
-css="""
-.radio-group .wrap {
-    display: grid !important;
-    grid-template-columns: 1fr 1fr;
-}
-
-.nav-holder {display: none;}
-
-.share-link {
-    display: inline-flex;
-    align-items: center;
-    background-color: #f0f0f0;
-    border-radius: 8px;
-    padding: 8px 12px;
-    margin: 10px 0;
-    font-family: monospace;
-    transition: all 0.2s ease;
-    cursor: pointer;
-    text-decoration: none;
-    color: #333;
-}
-
-.share-link:hover {
-    background-color: #e0e0e0;
-}
-
-.share-link .icon {
-    margin-left: 8px;
-}
-
-.title-row {
-    display: flex;
-    align-items: center;
-    justify-content: space-between;
-    margin-bottom: 1rem;
-}
-
-.title-row h2 {
-    margin: 0;
-}
-"""
-
-
-shortcut_js = """
-<script>
-// Handle URL parameters for direct language access
-const params = new URLSearchParams(window.location.search);
-const lang = params.get("lang");
-
-if (lang) {
-    window.location.href = "/" + lang;
-}
-
-// Function to copy link to clipboard
-const copyLinkToClipboard = (link) => {
-    navigator.clipboard.writeText(link);
-    console.log("Copied link to clipboard: " + link);
-}
-
-const redirect_to_lang = lang_descriptor => {
-    lang_code = lang_descriptor.split("(")[1].split(")")[0];
-    console.log("redirecting to /" + lang_code);
-    window.location.href = "/" + lang_code;
-}
-
-const empty_search = () => {
-    console.log("empty search");
-    document.getElementById("search-dropdown").value = "";
-}
-</script>
-"""
-
-
-# Create the visualization components
-with gr.Blocks(title="AI Language Proficiency Benchmark", css=css, head=shortcut_js) as demo:
-    language_choices = [
-        f"{lang['language_name']} ({lang['bcp_47']})" for lang in languages
-    ]
-    models = {score["model"] for lang in languages for score in lang["scores"]}
-    search = gr.Dropdown(
-        choices=language_choices, # + list(models),
-        value="Search for Language or Model",
-        allow_custom_value=True,
-        interactive=True,
-        container=False,
-        elem_id="search-dropdown"
-    )
-    search.focus(fn=lambda x: None, inputs=search, outputs=None, js="(x) => {empty_search()}")
-    search.change(fn=lambda x: None, inputs=search, outputs=None, js="(x) => {redirect_to_lang(x)}")
-    gr.Markdown("# AI Language Proficiency Benchmark")
-    gr.Markdown("Comparing language proficiency across different models and languages.")
-    with gr.Row():
-        start_model_type = "Text-to-Text"
-        model_type = gr.Radio(
-            choices=["Text-to-Text", "Speech-to-Text"],
-            value=start_model_type,
-            label="Select Model Type",
-            interactive=True,
-            elem_classes="radio-group",
-        )
-        start_metric = METRICS["t2t"][0]
-        metric = gr.Dropdown(
-            choices=[metric["display_name"] for metric in METRICS["t2t"]],
-            value=start_metric["display_name"],
-            label="Main task and metric to display in figures and map",
-            interactive=True,
-        )
-    with gr.Row():
-        with gr.Column():
-            with gr.Accordion("Model Filters", open=False):
-                model_licenses = gr.CheckboxGroup(
-                    choices=["open source", "commercial"],
-                    value=["open source", "commercial"],
-                    label="Filter by Model License",
-                    interactive=True,
-                )
-                model_sizes = RangeSlider(
-                    minimum=0,
-                    maximum=1000,
-                    value=(0, 1000),
-                    label="Filter by Model Size (in Billion Parameters)",
-                    interactive=True,
-                )
-        with gr.Column():
-            with gr.Accordion("Language Filters", open=False):
-                unit_of_analysis = gr.Radio(
-                    choices=["Languages", "Language Families", "Regions"],
-                    value="Languages",
-                    label="Select Unit of Analysis",
-                    interactive=True,
-                )
-                family_filter = gr.CheckboxGroup(
-                    choices=[
-                        "Indo-European",
-                        "Sino-Tibetan",
-                        "Afro-Asiatic",
-                        "Dravidian",
-                        "Uralic",
-                        "Austronesian",
-                        "Other",
-                    ],
-                    value=[
-                        "Indo-European",
-                        "Sino-Tibetan",
-                        "Afro-Asiatic",
-                        "Dravidian",
-                        "Uralic",
-                        "Austronesian",
-                        "Other",
-                    ],
-                    label="Filter by Language Family",
-                    interactive=True,
-                )
-                speakers_filter = RangeSlider(
-                    minimum=0,
-                    maximum=100_000_000,
-                    value=(0, 100_000_000),
-                    label="Filter by Number of Speakers",
-                    interactive=True,
-                )
-
-    gr.Markdown("## Model Comparison")
-    leaderboard_df = create_leaderboard_df("t2t", start_metric)
-
-    model_comparison_plot = gr.Plot(
-        value=create_model_comparison_plot(start_metric),
-        label="Model Comparison",
-    )
-
-    gr.Markdown("## Language Stats")
-    create_language_stats_df(start_metric)
-    scatter_plot = gr.Plot(
-        value=create_scatter_plot(start_metric),
-        label="Speaker Population vs. Metric",
-    )
-    world_map = gr.Plot(
-        value=create_world_map(start_metric),
-        label="World Map",
-        container=False,
-        elem_classes="fullwidth-plot",
-    )
-
-    def update_model_type(model_type_choice):
-        model_type = {"Text-to-Text": "t2t", "Speech-to-Text": "s2t"}[model_type_choice]
-        return create_metric_selector(model_type), create_leaderboard_df(model_type)
-
-    model_type.change(
-        fn=update_model_type,
-        inputs=model_type,
-        outputs=[metric, leaderboard_df],
-    )
-
-    def update_component(fn, model_type_choice, metric_choice):
-        model_type = {"Text-to-Text": "t2t", "Speech-to-Text": "s2t"}[model_type_choice]
-        metric = [m for m in METRICS[model_type] if m["display_name"] == metric_choice][
-            0
-        ]
-        return fn(metric)
-    metric.change(
-        fn=partial(update_component, create_model_comparison_plot),
-        inputs=[model_type, metric],
-        outputs=model_comparison_plot,
-    )
-    metric.change(
-        fn=partial(update_component, create_scatter_plot),
-        inputs=[model_type, metric],
-        outputs=scatter_plot,
-    )
-    metric.change(
-        fn=partial(update_component, create_world_map),
-        inputs=[model_type, metric],
-        outputs=world_map,
-    )
-
-    with gr.Accordion("Methodology", open=False):
-        gr.Markdown(
-            """
-            ### Benchmark Data
-            We use the [FLORES+](https://huggingface.co/datasets/openlanguagedata/flores_plus) dataset for evaluation, which contains parallel text in over 200 languages, as well as topic labels for each sentence. Where FLORES+ includes multiple scripts for one language, we use only the most common one.
-
-            Population and speaker data and language code resolution are from Unicode [CLDR](https://github.com/unicode-org/cldr) via the [langcodes](https://github.com/rspeer/langcodes) package.
-
-            ### AI Models
-            We use [OpenRouter](https://openrouter.ai/) to access all relevant AI models via a unified API.
-
-            ### Evaluation Tasks
-            Our benchmark includes three core tasks to assess different aspects of language understanding:
-
-            1. **Machine Translation**: Models translate text _from_ the evaluated language _to_ a fixed set of target languages. The set of target languages is representative of global speaker populations. Performance is measured using:
-            - [BLEU Score](https://huggingface.co/metrics/bleu): Measures n-gram precision with a brevity penalty
-            - [ChrF Score](https://huggingface.co/metrics/chrf): Character-level F-score that better captures morphological variations
-
-            2. **Text Classification**: Models classify text into predefined topics after being shown examples. We:
-            - Group sentences by URL into paragraphs with the same topic
-            - Use the 5 most common topics, encoded as numbers rather than English labels
-            - Provide 5 examples of each topic as few-shot examples
-            - Test the model's ability to classify new text
-            - Report accuracy as the primary metric
-
-            3. **Masked Language Modeling**: Models predict missing portions of text (marked with `<mask>`). We:
-            - Mask approximately 5% of each sentence at a random position
-            - Provide 10 examples of complete sentences paired with masked versions in a few-shot setting
-            - Evaluate predictions using ChrF score against the original text
-
-            The overall performance score combines metrics from all tasks to provide a holistic assessment of model capabilities across languages.
-        """
-        )
-
-
-for lang in tqdm(languages[:20], desc="Generating pages"):
-    with demo.route(lang['language_name'], f"/{lang['bcp_47']}"):
-        gr.Button("← Back to Main Dashboard", link="/")
-        url = f"hf.co/spaces/datenlaborbmz/ai-language-monitor?lang={lang['bcp_47']}"
-        gr.Markdown(
-            f'''
-            <div class="title-row">
-                <h2>{lang['language_name']}</h2>
-                <div class="share-link" onclick="copyLinkToClipboard('{url}')">{url}<span class="icon">📋</span></div>
-            </div>
-            ''', 
-            sanitize_html=False
-        )
-        
-        # Language overview section
-        with gr.Row():
-            with gr.Column(scale=2):
-                gr.Markdown(f"""
-                ## Language Overview
-                - **Native name**: {lang.get('native_name', 'N/A')}
-                - **Language family**: {lang.get('language_family', 'N/A')}
-                - **BCP-47 code**: `{lang['bcp_47']}`
-                - **ISO 639-3 code**: `{lang.get('iso_639_3', 'N/A')}`
-                - **Number of speakers**: {format_number(lang['speakers'])} 
-                - **Script**: {lang.get('script', 'N/A')}
-                - **CommonVoice hours**: {round(lang.get('commonvoice_hours', 0) or 0)}
-                """)
-                
-                # Resource links
-                resource_links = []
-                if lang.get('commonvoice_locale'):
-                    resource_links.append(f"[CommonVoice Dataset](https://commonvoice.mozilla.org/{lang['commonvoice_locale']})")
-                if lang.get('wikipedia_code'):
-                    resource_links.append(f"[Wikipedia](https://{lang['wikipedia_code']}.wikipedia.org)")
-                if lang.get('bcp_47'):
-                    resource_links.append(f"[FLORES+ Dataset](https://huggingface.co/datasets/openlanguagedata/flores_plus/viewer/all/{lang['bcp_47']})")
-                
-                if resource_links:
-                    gr.Markdown("### Resources\n" + "\n".join(resource_links))
-            
-            with gr.Column(scale=3):
-                # Create a mini-map showing where the language is spoken
-                country_data = {}
-                if "population" in lang:
-                    for country_code, speakers in lang["population"].items():
-                        try:
-                            country = pycountry.countries.get(alpha_2=country_code)
-                            if country:
-                                country_data[country.alpha_3] = speakers / lang["speakers"]
-                        except (KeyError, AttributeError):
-                            continue
-                
-                locations = list(country_data.keys())
-                values = list(country_data.values())
-                
-                if locations:
-                    fig = go.Figure(data=go.Choropleth(
-                        locations=locations,
-                        z=values,
-                        locationmode="ISO-3",
-                        colorscale="Blues",
-                        marker_line_color='white',
-                        marker_line_width=0.5,
-                        colorbar_title="Speaker %"
-                    ))
-                    
-                    fig.update_layout(
-                        title_text=f"Distribution of {lang['language_name']} Speakers",
-                        geo=dict(
-                            showframe=False,
-                            showcoastlines=True,
-                            projection_type='natural earth'
-                        ),
-                        height=300,
-                        margin={"r":0,"t":30,"l":0,"b":0}
-                    )
-                    
-                    gr.Plot(value=fig)
-                else:
-                    gr.Markdown("*Geographic data not available*")
-        
-        # Performance metrics section
-        gr.Markdown("## AI Model Performance")
-        
-        with gr.Row():
-            with gr.Column():
-                # Create metrics dashboard for this language
-                metrics_data = []
-                for metric_key, display_name in [
-                    ("t2t_score", "Overall Text Performance"), 
-                    ("mt_bleu", "Translation (BLEU)"),
-                    ("mt_chrf", "Translation (ChrF)"),
-                    ("cls_acc", "Classification"),
-                    ("mlm_chrf", "Masked Language Modeling"),
-                    ("s2t_score", "Overall Speech Performance"),
-                    ("asr_wer", "Speech Recognition (WER)"),
-                    ("asr_chrf", "Speech Recognition (ChrF)")
-                ]:
-                    if metric_key in lang and lang[metric_key] is not None:
-                        value = lang[metric_key]
-                        color = "green" if value > 0.5 else "orange" if value > 0.25 else "red"
-                        
-                        # For WER, lower is better, so invert the color logic
-                        if metric_key == "asr_wer":
-                            color = "green" if value < 0.3 else "orange" if value < 0.6 else "red"
-                        
-                        metrics_data.append({
-                            "Metric": display_name,
-                            "Value": round(value, 3),
-                            "Visual": make_colored_bar(value if metric_key != "asr_wer" else 1 - value)
-                        })
-                
-                if metrics_data:
-                    gr.DataFrame(
-                        pd.DataFrame(metrics_data),
-                        label=f"Performance Metrics for {lang['language_name']}",
-                        show_search=False
-                    )
-                else:
-                    gr.Markdown("*No performance metrics available*")
-        
-        # Model comparison table
-        gr.Markdown("## Model Comparison")
-        
-        with gr.Row():
-            models_data = []
-            for score in lang["scores"]:
-                if score.get("t2t_score") is not None:
-                    model_name = score["model"].split("/")[-1]
-                    models_data.append({
-                        "Model": model_name,
-                        "Overall": round(score.get("t2t_score", 0), 3),
-                        "Translation": round(score.get("mt_chrf", 0), 3),
-                        "Classification": round(score.get("cls_acc", 0), 3),
-                        "Lang Model": round(score.get("mlm_chrf", 0), 3),
-                        "Speech": round(score.get("asr_chrf", 0), 3) if "asr_chrf" in score else "N/A"
-                    })
-            
-            if models_data:
-                df = pd.DataFrame(models_data).sort_values("Overall", ascending=False)
-                gr.DataFrame(
-                    df,
-                    label=f"Model Performance on {lang['language_name']}",
-                    show_search=False
-                )
-            else:
-                gr.Markdown("*No model comparison data available*")
-        
-        # Performance comparison with similar languages
-        if lang.get("language_family"):
-            gr.Markdown("## Comparison with Related Languages")
-            
-            # Find related languages
-            related_langs = [l for l in languages if l.get("language_family") == lang["language_family"] and l["t2t_score"] is not None]
-            related_langs = sorted(related_langs, key=lambda x: x["t2t_score"], reverse=True)[:10]
-            
-            if len(related_langs) > 1:
-                lang_names = [l["language_name"] for l in related_langs]
-                t2t_scores = [l["t2t_score"] for l in related_langs]
-                
-                fig = px.bar(
-                    x=lang_names, 
-                    y=t2t_scores,
-                    labels={"x": "Language", "y": "Text-to-Text Score"},
-                    title=f"Performance Across {lang['language_family']} Languages"
-                )
-                
-                # Highlight the current language
-                for i, name in enumerate(lang_names):
-                    if name == lang["language_name"]:
-                        fig.data[0].marker.color = ["lightblue"] * i + ["orange"] + ["lightblue"] * (len(lang_names) - i - 1)
-                
-                fig.update_layout(height=400)
-                gr.Plot(value=fig)
-
-
-demo.launch()

evals/backend.py

@@ -0,0 +1,46 @@
+import json
+
+import numpy as np
+import pandas as pd
+import uvicorn
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.middleware.gzip import GZipMiddleware
+from fastapi.responses import JSONResponse
+from fastapi.staticfiles import StaticFiles
+from languages import languages
+from models import models
+from tables import aggregate, make_country_table, make_language_table, make_model_table
+
+app = FastAPI()
+
+app.add_middleware(CORSMiddleware, allow_origins=["*"])
+app.add_middleware(GZipMiddleware, minimum_size=1000)
+
+with open("results.json", "r") as f:
+    results = json.load(f)
+
+
+def serialize(df):
+    return df.replace({np.nan: None}).to_dict(orient="records")
+
+
+@app.post("/api/data")
+def data():
+    _, lang_results, model_results, task_results = aggregate(results)
+    model_table = make_model_table(model_results, models)
+    language_table = make_language_table(lang_results, languages)
+    datasets_df = pd.read_json("data/datasets.json")
+    countries = make_country_table(language_table)
+    all_tables = {
+        "model_table": serialize(model_table),
+        "language_table": serialize(language_table),
+        "dataset_table": serialize(datasets_df),
+        "countries": serialize(countries),
+    }
+    return JSONResponse(content=all_tables)
+
+app.mount("/", StaticFiles(directory="frontend/public", html=True), name="frontend")
+
+if __name__ == "__main__":
+    uvicorn.run(app, host="0.0.0.0", port=8000)

evals/countries.py

@@ -2,7 +2,7 @@ import re
 import xml.etree.ElementTree as ET
 from collections import defaultdict
 
-import pycountry
+import pandas as pd
 from language_data.population_data import LANGUAGE_SPEAKING_POPULATION
 from language_data.util import data_filename
 
@@ -38,7 +38,7 @@ def make_country_table(language_table):
                     "name": lang.language_name,
                     "bcp_47": lang.bcp_47,
                     "population": speaker_pop,
-                    "score": lang.average,
+                    "score": lang.average if not pd.isna(lang.average) else 0,
                 }
             )
     for country, languages in countries.items():
@@ -51,4 +51,5 @@ def make_country_table(language_table):
             "score": score,
             "languages": languages,
         }
-    return countries
+    countries = [{"iso2": country, **data} for country, data in countries.items()]
+    return pd.DataFrame(countries)

evals/main.py

@@ -2,8 +2,6 @@ import asyncio
 import json
 
 import numpy as np
-import pandas as pd
-from countries import make_country_table
 from languages import languages
 from models import model_fast, models
 from rich import print
@@ -38,128 +36,11 @@ async def evaluate():
     return await tqdm_asyncio.gather(*results, miniters=1)
 
 
-def aggregate(results):
-    results = pd.DataFrame([r for rs in results for r in rs])
-    results = (
-        results.groupby(["model", "bcp_47", "task", "metric"]).mean().reset_index()
-    )
-    lang_results = (
-        results.groupby(["bcp_47", "task", "metric"])
-        .agg({"score": "mean", "model": "nunique"})
-        .reset_index()
-    )
-    lang_results = pd.merge(languages, lang_results, on="bcp_47", how="outer")
-    model_results = (
-        results.groupby(["model", "task", "metric"])
-        .agg({"score": "mean", "bcp_47": "nunique"})
-        .reset_index()
-    )
-    task_results = (
-        results.groupby(["task", "metric"])
-        .agg({"score": "mean", "bcp_47": "nunique", "model": "nunique"})
-        .reset_index()
-    )
-    return results, lang_results, model_results, task_results
-
-
-def mean(lst):
-    return sum(lst) / len(lst) if lst else None
-
-
-def fmt_name(s):
-    return (
-        " ".join(w.capitalize() for w in s.split("-"))
-        .replace("Gpt", "GPT")
-        .replace("ai", "AI")
-    )
-
-
-def serialize(df):
-    return df.replace({np.nan: None}).to_dict(orient="records")
-
-
-def make_model_table(df):
-    df["task_metric"] = df["task"] + "_" + df["metric"]
-    df = df.drop(columns=["task", "metric"])
-    task_metrics = df["task_metric"].unique()
-    df = df.pivot(index="model", columns="task_metric", values="score").fillna(0)
-    df["average"] = df[task_metrics].mean(axis=1)
-    df = df.sort_values(by="average", ascending=False).reset_index()
-    for row in [*task_metrics, "average"]:
-        df[row] = df[row].round(2)
-    df = pd.merge(df, models, left_on="model", right_on="id", how="left")
-    df["creation_date"] = df["creation_date"].dt.strftime("%Y-%m-%d")
-    df["provider"] = df["model"].str.split("/").str[0].apply(fmt_name)
-    df["model"] = df["model"].str.split("/").str[1].apply(fmt_name)
-    df["rank"] = df.index + 1
-    df = df[
-        [
-            "rank",
-            "provider",
-            "model",
-            "hf_id",
-            "creation_date",
-            "size",
-            "type",
-            "license",
-            "average",
-            *task_metrics,
-        ]
-    ]
-    return df
-
-
-def make_language_table(df):
-    df["task_metric"] = df["task"] + "_" + df["metric"]
-    df = df.drop(columns=["task", "metric"])
-    task_metrics = df["task_metric"].unique()
-    df = (
-        df.pivot(index="bcp_47", columns="task_metric", values="score")
-        .fillna(0)
-        .reset_index()
-    )
-    df["average"] = df[task_metrics].mean(axis=1)
-    for row in [*task_metrics, "average"]:
-        df[row] = df[row].round(2)
-    df = pd.merge(languages, df, on="bcp_47", how="outer")
-    df = df.sort_values(by="speakers", ascending=False)
-    df = df[
-        [
-            "bcp_47",
-            "language_name",
-            "autonym",
-            "speakers",
-            "family",
-            "average",
-            "in_benchmark",
-            *task_metrics,
-        ]
-    ]
-    return df
-
 
 async def main():
     results = await evaluate()
-    results, lang_results, model_results, task_results = aggregate(results)
-    all_results = {
-        "tasks": serialize(task_results),
-        "models": serialize(model_results),
-        "languages": serialize(lang_results),
-        "scores": serialize(results),
-    }
     with open("results.json", "w") as f:
-        json.dump(all_results, f, indent=2, ensure_ascii=False)
-
-    datasets_df = pd.read_json("data/datasets.json")
-    language_table = make_language_table(lang_results)
-    all_tables = {
-        "model_table": serialize(make_model_table(model_results)),
-        "language_table": serialize(language_table),
-        "dataset_table": serialize(datasets_df),
-        "countries": make_country_table(language_table),
-    }
-    with open("frontend/public/results.json", "w") as f:
-        json.dump(all_tables, f, indent=2, ensure_ascii=False)
+        json.dump(results, f, indent=2, ensure_ascii=False)
 
 
 if __name__ == "__main__":

evals/tables.py

@@ -0,0 +1,100 @@
+import pandas as pd
+from countries import make_country_table
+
+make_country_table = make_country_table
+
+
+def aggregate(results):
+    results = pd.DataFrame([r for rs in results for r in rs])
+    results = (
+        results.groupby(["model", "bcp_47", "task", "metric"]).mean().reset_index()
+    )
+    lang_results = (
+        results.groupby(["bcp_47", "task", "metric"])
+        .agg({"score": "mean", "model": "nunique"})
+        .reset_index()
+    )
+    # lang_results = pd.merge(languages, lang_results, on="bcp_47", how="outer")
+    model_results = (
+        results.groupby(["model", "task", "metric"])
+        .agg({"score": "mean", "bcp_47": "nunique"})
+        .reset_index()
+    )
+    task_results = (
+        results.groupby(["task", "metric"])
+        .agg({"score": "mean", "bcp_47": "nunique", "model": "nunique"})
+        .reset_index()
+    )
+    return results, lang_results, model_results, task_results
+
+
+def mean(lst):
+    return sum(lst) / len(lst) if lst else None
+
+
+def fmt_name(s):
+    return (
+        " ".join(w.capitalize() for w in s.split("-"))
+        .replace("Gpt", "GPT")
+        .replace("ai", "AI")
+    )
+
+
+def make_model_table(df, models):
+    df["task_metric"] = df["task"] + "_" + df["metric"]
+    df = df.drop(columns=["task", "metric"])
+    task_metrics = df["task_metric"].unique()
+    df = df.pivot(index="model", columns="task_metric", values="score").fillna(0)
+    df["average"] = df[task_metrics].mean(axis=1)
+    df = df.sort_values(by="average", ascending=False).reset_index()
+    for row in [*task_metrics, "average"]:
+        df[row] = df[row].round(2)
+    df = pd.merge(df, models, left_on="model", right_on="id", how="left")
+    df["creation_date"] = df["creation_date"].dt.strftime("%Y-%m-%d")
+    df["provider"] = df["model"].str.split("/").str[0].apply(fmt_name)
+    df["model"] = df["model"].str.split("/").str[1].apply(fmt_name)
+    df["rank"] = df.index + 1
+    df = df[
+        [
+            "rank",
+            "provider",
+            "model",
+            "hf_id",
+            "creation_date",
+            "size",
+            "type",
+            "license",
+            "average",
+            *task_metrics,
+        ]
+    ]
+    return df
+
+
+def make_language_table(df, languages):
+    df["task_metric"] = df["task"] + "_" + df["metric"]
+    df = df.drop(columns=["task", "metric"])
+    task_metrics = df["task_metric"].unique()
+    df = (
+        df.pivot(index="bcp_47", columns="task_metric", values="score")
+        .fillna(0)
+        .reset_index()
+    )
+    df["average"] = df[task_metrics].mean(axis=1)
+    for row in [*task_metrics, "average"]:
+        df[row] = df[row].round(2)
+    df = pd.merge(languages, df, on="bcp_47", how="outer")
+    df = df.sort_values(by="speakers", ascending=False)
+    df = df[
+        [
+            "bcp_47",
+            "language_name",
+            "autonym",
+            "speakers",
+            "family",
+            "average",
+            "in_benchmark",
+            *task_metrics,
+        ]
+    ]
+    return df

frontend/package.json

@@ -40,5 +40,6 @@
       "last 1 firefox version",
       "last 1 safari version"
     ]
-  }
+  },
+  "proxy": "http://localhost:8000"
 }

frontend/src/App.js

@@ -26,7 +26,10 @@ function App () {
     size: { value: null, matchMode: FilterMatchMode.BETWEEN }
   })
   useEffect(() => {
-    fetch('/results.json')
+    fetch('/api/data', {
+      method: 'POST',
+      // body: JSON.stringify({ modelFilters, languageFilters }),
+    })
       .then(response => {
         if (!response.ok) {
           throw new Error('Network response was not ok')
@@ -41,7 +44,7 @@ function App () {
         setError(err.message)
         setLoading(false)
       })
-  }, [])
+  }, [modelFilters, languageFilters])
 
   useEffect(() => {
     if (data) {
@@ -150,7 +153,7 @@ function App () {
                 }}
               >
                 <ModelTable
-                  data={data}
+                  data={data.model_table}
                   filters={modelFilters}
                   setFilters={setModelFilters}
                 />
@@ -162,7 +165,7 @@ function App () {
                 }}
               >
                 <LanguageTable
-                  data={data}
+                  data={data.language_table}
                   filters={languageFilters}
                   setFilters={setLanguageFilters}
                 />

frontend/src/components/LanguageTable.js

@@ -7,9 +7,7 @@ import { Slider } from 'primereact/slider'
 import ScoreField from './ScoreField'
 
 const LanguageTable = ({ data, filters, setFilters }) => {
-  const table = data.language_table
-
-  const families = [...new Set(table.map(item => item.family))].slice(0, 10)
+  const families = [...new Set(data.map(item => item.family))].slice(0, 10)
   families.push("Other")
   const familyRowFilterTemplate = options => {
     return (
@@ -120,7 +118,7 @@ const LanguageTable = ({ data, filters, setFilters }) => {
 
   return (
     <DataTable
-      value={table}
+      value={data}
       header={<>Languages</>}
       sortField='speakers'
       removableSort

frontend/src/components/ModelTable.js

@@ -8,7 +8,6 @@ import { Slider } from 'primereact/slider'
 import ScoreField from './ScoreField'
 
 const ModelTable = ({ data, filters, setFilters }) => {
-  const table = data.model_table
   const rankBodyTemplate = rowData => {
     return <Medal rank={rowData.rank} />
   }
@@ -125,7 +124,7 @@ const ModelTable = ({ data, filters, setFilters }) => {
 
   return (
     <DataTable
-      value={table}
+      value={data}
       header={<>AI Models</>}
       sortField='average'
       removableSort

pyproject.toml

@@ -5,12 +5,10 @@ description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-    "gradio-rangeslider>=0.0.8",
-    "gradio>=5.16.2",
-    "language-data>=1.3.0",
+    "fastapi>=0.115.8",
+    "uvicorn>=0.34.0",
     "pandas>=2.2.3",
-    "plotly>=6.0.0",
-    "pycountry>=24.6.1",
+    "numpy>=2.1.2",
 ]
 
 [tool.uv]
@@ -23,6 +21,7 @@ dev-dependencies = [
     "jiwer>=3.1.0",
     "joblib>=1.4.2",
     "langcodes>=3.5.0",
+    "language-data>=1.3.0",
     "openai>=1.52.2",
     "protobuf>=5.28.3",
     "python-dotenv>=1.0.1",

uv.lock

@@ -7,15 +7,6 @@ resolution-markers = [
     "python_full_version >= '3.13'",
 ]
 
-[[package]]
-name = "aiofiles"
-version = "23.2.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/af/41/cfed10bc64d774f497a86e5ede9248e1d062db675504b41c320954d99641/aiofiles-23.2.1.tar.gz", hash = "sha256:84ec2218d8419404abcb9f0c02df3f34c6e0a68ed41072acfb1cef5cbc29051a", size = 32072 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c5/19/5af6804c4cc0fed83f47bff6e413a98a36618e7d40185cd36e69737f3b0e/aiofiles-23.2.1-py3-none-any.whl", hash = "sha256:19297512c647d4b27a2cf7c34caa7e405c0d60b5560618a29a9fe027b18b0107", size = 15727 },
-]
-
 [[package]]
 name = "aiohappyeyeballs"
 version = "2.4.3"
@@ -165,46 +156,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/6a/21/5b6702a7f963e95456c0de2d495f67bf5fd62840ac655dc451586d23d39a/attrs-24.2.0-py3-none-any.whl", hash = "sha256:81921eb96de3191c8258c199618104dd27ac608d9366f5e35d011eae1867ede2", size = 63001 },
 ]
 
-[[package]]
-name = "audioop-lts"
-version = "0.2.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/dd/3b/69ff8a885e4c1c42014c2765275c4bd91fe7bc9847e9d8543dbcbb09f820/audioop_lts-0.2.1.tar.gz", hash = "sha256:e81268da0baa880431b68b1308ab7257eb33f356e57a5f9b1f915dfb13dd1387", size = 30204 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/01/91/a219253cc6e92db2ebeaf5cf8197f71d995df6f6b16091d1f3ce62cb169d/audioop_lts-0.2.1-cp313-abi3-macosx_10_13_universal2.whl", hash = "sha256:fd1345ae99e17e6910f47ce7d52673c6a1a70820d78b67de1b7abb3af29c426a", size = 46252 },
-    { url = "https://files.pythonhosted.org/packages/ec/f6/3cb21e0accd9e112d27cee3b1477cd04dafe88675c54ad8b0d56226c1e0b/audioop_lts-0.2.1-cp313-abi3-macosx_10_13_x86_64.whl", hash = "sha256:e175350da05d2087e12cea8e72a70a1a8b14a17e92ed2022952a4419689ede5e", size = 27183 },
-    { url = "https://files.pythonhosted.org/packages/ea/7e/f94c8a6a8b2571694375b4cf94d3e5e0f529e8e6ba280fad4d8c70621f27/audioop_lts-0.2.1-cp313-abi3-macosx_11_0_arm64.whl", hash = "sha256:4a8dd6a81770f6ecf019c4b6d659e000dc26571b273953cef7cd1d5ce2ff3ae6", size = 26726 },
-    { url = "https://files.pythonhosted.org/packages/ef/f8/a0e8e7a033b03fae2b16bc5aa48100b461c4f3a8a38af56d5ad579924a3a/audioop_lts-0.2.1-cp313-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d1cd3c0b6f2ca25c7d2b1c3adeecbe23e65689839ba73331ebc7d893fcda7ffe", size = 80718 },
-    { url = "https://files.pythonhosted.org/packages/8f/ea/a98ebd4ed631c93b8b8f2368862cd8084d75c77a697248c24437c36a6f7e/audioop_lts-0.2.1-cp313-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ff3f97b3372c97782e9c6d3d7fdbe83bce8f70de719605bd7ee1839cd1ab360a", size = 88326 },
-    { url = "https://files.pythonhosted.org/packages/33/79/e97a9f9daac0982aa92db1199339bd393594d9a4196ad95ae088635a105f/audioop_lts-0.2.1-cp313-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a351af79edefc2a1bd2234bfd8b339935f389209943043913a919df4b0f13300", size = 80539 },
-    { url = "https://files.pythonhosted.org/packages/b2/d3/1051d80e6f2d6f4773f90c07e73743a1e19fcd31af58ff4e8ef0375d3a80/audioop_lts-0.2.1-cp313-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2aeb6f96f7f6da80354330470b9134d81b4cf544cdd1c549f2f45fe964d28059", size = 78577 },
-    { url = "https://files.pythonhosted.org/packages/7a/1d/54f4c58bae8dc8c64a75071c7e98e105ddaca35449376fcb0180f6e3c9df/audioop_lts-0.2.1-cp313-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c589f06407e8340e81962575fcffbba1e92671879a221186c3d4662de9fe804e", size = 82074 },
-    { url = "https://files.pythonhosted.org/packages/36/89/2e78daa7cebbea57e72c0e1927413be4db675548a537cfba6a19040d52fa/audioop_lts-0.2.1-cp313-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:fbae5d6925d7c26e712f0beda5ed69ebb40e14212c185d129b8dfbfcc335eb48", size = 84210 },
-    { url = "https://files.pythonhosted.org/packages/a5/57/3ff8a74df2ec2fa6d2ae06ac86e4a27d6412dbb7d0e0d41024222744c7e0/audioop_lts-0.2.1-cp313-abi3-musllinux_1_2_i686.whl", hash = "sha256:d2d5434717f33117f29b5691fbdf142d36573d751716249a288fbb96ba26a281", size = 85664 },
-    { url = "https://files.pythonhosted.org/packages/16/01/21cc4e5878f6edbc8e54be4c108d7cb9cb6202313cfe98e4ece6064580dd/audioop_lts-0.2.1-cp313-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:f626a01c0a186b08f7ff61431c01c055961ee28769591efa8800beadd27a2959", size = 93255 },
-    { url = "https://files.pythonhosted.org/packages/3e/28/7f7418c362a899ac3b0bf13b1fde2d4ffccfdeb6a859abd26f2d142a1d58/audioop_lts-0.2.1-cp313-abi3-musllinux_1_2_s390x.whl", hash = "sha256:05da64e73837f88ee5c6217d732d2584cf638003ac72df124740460531e95e47", size = 87760 },
-    { url = "https://files.pythonhosted.org/packages/6d/d8/577a8be87dc7dd2ba568895045cee7d32e81d85a7e44a29000fe02c4d9d4/audioop_lts-0.2.1-cp313-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:56b7a0a4dba8e353436f31a932f3045d108a67b5943b30f85a5563f4d8488d77", size = 84992 },
-    { url = "https://files.pythonhosted.org/packages/ef/9a/4699b0c4fcf89936d2bfb5425f55f1a8b86dff4237cfcc104946c9cd9858/audioop_lts-0.2.1-cp313-abi3-win32.whl", hash = "sha256:6e899eb8874dc2413b11926b5fb3857ec0ab55222840e38016a6ba2ea9b7d5e3", size = 26059 },
-    { url = "https://files.pythonhosted.org/packages/3a/1c/1f88e9c5dd4785a547ce5fd1eb83fff832c00cc0e15c04c1119b02582d06/audioop_lts-0.2.1-cp313-abi3-win_amd64.whl", hash = "sha256:64562c5c771fb0a8b6262829b9b4f37a7b886c01b4d3ecdbae1d629717db08b4", size = 30412 },
-    { url = "https://files.pythonhosted.org/packages/c4/e9/c123fd29d89a6402ad261516f848437472ccc602abb59bba522af45e281b/audioop_lts-0.2.1-cp313-abi3-win_arm64.whl", hash = "sha256:c45317debeb64002e980077642afbd977773a25fa3dfd7ed0c84dccfc1fafcb0", size = 23578 },
-    { url = "https://files.pythonhosted.org/packages/7a/99/bb664a99561fd4266687e5cb8965e6ec31ba4ff7002c3fce3dc5ef2709db/audioop_lts-0.2.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:3827e3fce6fee4d69d96a3d00cd2ab07f3c0d844cb1e44e26f719b34a5b15455", size = 46827 },
-    { url = "https://files.pythonhosted.org/packages/c4/e3/f664171e867e0768ab982715e744430cf323f1282eb2e11ebfb6ee4c4551/audioop_lts-0.2.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:161249db9343b3c9780ca92c0be0d1ccbfecdbccac6844f3d0d44b9c4a00a17f", size = 27479 },
-    { url = "https://files.pythonhosted.org/packages/a6/0d/2a79231ff54eb20e83b47e7610462ad6a2bea4e113fae5aa91c6547e7764/audioop_lts-0.2.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5b7b4ff9de7a44e0ad2618afdc2ac920b91f4a6d3509520ee65339d4acde5abf", size = 27056 },
-    { url = "https://files.pythonhosted.org/packages/86/46/342471398283bb0634f5a6df947806a423ba74b2e29e250c7ec0e3720e4f/audioop_lts-0.2.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:72e37f416adb43b0ced93419de0122b42753ee74e87070777b53c5d2241e7fab", size = 87802 },
-    { url = "https://files.pythonhosted.org/packages/56/44/7a85b08d4ed55517634ff19ddfbd0af05bf8bfd39a204e4445cd0e6f0cc9/audioop_lts-0.2.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:534ce808e6bab6adb65548723c8cbe189a3379245db89b9d555c4210b4aaa9b6", size = 95016 },
-    { url = "https://files.pythonhosted.org/packages/a8/2a/45edbca97ea9ee9e6bbbdb8d25613a36e16a4d1e14ae01557392f15cc8d3/audioop_lts-0.2.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d2de9b6fb8b1cf9f03990b299a9112bfdf8b86b6987003ca9e8a6c4f56d39543", size = 87394 },
-    { url = "https://files.pythonhosted.org/packages/14/ae/832bcbbef2c510629593bf46739374174606e25ac7d106b08d396b74c964/audioop_lts-0.2.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f24865991b5ed4b038add5edbf424639d1358144f4e2a3e7a84bc6ba23e35074", size = 84874 },
-    { url = "https://files.pythonhosted.org/packages/26/1c/8023c3490798ed2f90dfe58ec3b26d7520a243ae9c0fc751ed3c9d8dbb69/audioop_lts-0.2.1-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bdb3b7912ccd57ea53197943f1bbc67262dcf29802c4a6df79ec1c715d45a78", size = 88698 },
-    { url = "https://files.pythonhosted.org/packages/2c/db/5379d953d4918278b1f04a5a64b2c112bd7aae8f81021009da0dcb77173c/audioop_lts-0.2.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:120678b208cca1158f0a12d667af592e067f7a50df9adc4dc8f6ad8d065a93fb", size = 90401 },
-    { url = "https://files.pythonhosted.org/packages/99/6e/3c45d316705ab1aec2e69543a5b5e458d0d112a93d08994347fafef03d50/audioop_lts-0.2.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:54cd4520fc830b23c7d223693ed3e1b4d464997dd3abc7c15dce9a1f9bd76ab2", size = 91864 },
-    { url = "https://files.pythonhosted.org/packages/08/58/6a371d8fed4f34debdb532c0b00942a84ebf3e7ad368e5edc26931d0e251/audioop_lts-0.2.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:d6bd20c7a10abcb0fb3d8aaa7508c0bf3d40dfad7515c572014da4b979d3310a", size = 98796 },
-    { url = "https://files.pythonhosted.org/packages/ee/77/d637aa35497e0034ff846fd3330d1db26bc6fd9dd79c406e1341188b06a2/audioop_lts-0.2.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:f0ed1ad9bd862539ea875fb339ecb18fcc4148f8d9908f4502df28f94d23491a", size = 94116 },
-    { url = "https://files.pythonhosted.org/packages/1a/60/7afc2abf46bbcf525a6ebc0305d85ab08dc2d1e2da72c48dbb35eee5b62c/audioop_lts-0.2.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:e1af3ff32b8c38a7d900382646e91f2fc515fd19dea37e9392275a5cbfdbff63", size = 91520 },
-    { url = "https://files.pythonhosted.org/packages/65/6d/42d40da100be1afb661fd77c2b1c0dfab08af1540df57533621aea3db52a/audioop_lts-0.2.1-cp313-cp313t-win32.whl", hash = "sha256:f51bb55122a89f7a0817d7ac2319744b4640b5b446c4c3efcea5764ea99ae509", size = 26482 },
-    { url = "https://files.pythonhosted.org/packages/01/09/f08494dca79f65212f5b273aecc5a2f96691bf3307cac29acfcf84300c01/audioop_lts-0.2.1-cp313-cp313t-win_amd64.whl", hash = "sha256:f0f2f336aa2aee2bce0b0dcc32bbba9178995454c7b979cf6ce086a8801e14c7", size = 30780 },
-    { url = "https://files.pythonhosted.org/packages/5d/35/be73b6015511aa0173ec595fc579133b797ad532996f2998fd6b8d1bbe6b/audioop_lts-0.2.1-cp313-cp313t-win_arm64.whl", hash = "sha256:78bfb3703388c780edf900be66e07de5a3d4105ca8e8720c5c4d67927e0b15d0", size = 23918 },
-]
-
 [[package]]
 name = "bert-score"
 version = "0.3.13"
@@ -500,15 +451,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/8f/7d/2d6ce181d7a5f51dedb8c06206cbf0ec026a99bf145edd309f9e17c3282f/fastapi-0.115.8-py3-none-any.whl", hash = "sha256:753a96dd7e036b34eeef8babdfcfe3f28ff79648f86551eb36bfc1b0bf4a8cbf", size = 94814 },
 ]
 
-[[package]]
-name = "ffmpy"
-version = "0.5.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/4d/66/5697a7421c418ccbfae87b7e6503b480070f7cb16c25c77201afc6246348/ffmpy-0.5.0.tar.gz", hash = "sha256:277e131f246d18e9dcfee9bb514c50749031c43582ce5ef82c57b51e3d3955c3", size = 5523 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/53/5d/65f40bd333463b3230b3a72d93873caaf49b0cbb5228598fafb75fcc5357/ffmpy-0.5.0-py3-none-any.whl", hash = "sha256:df3799cf5816daa56d4959a023630ee53c6768b66009dae6d131519ba4b80233", size = 6008 },
-]
-
 [[package]]
 name = "filelock"
 version = "3.16.1"
@@ -640,73 +582,6 @@ http = [
     { name = "aiohttp" },
 ]
 
-[[package]]
-name = "gradio"
-version = "5.16.2"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "aiofiles" },
-    { name = "anyio" },
-    { name = "audioop-lts", marker = "python_full_version >= '3.13'" },
-    { name = "fastapi" },
-    { name = "ffmpy" },
-    { name = "gradio-client" },
-    { name = "httpx" },
-    { name = "huggingface-hub" },
-    { name = "jinja2" },
-    { name = "markupsafe" },
-    { name = "numpy" },
-    { name = "orjson" },
-    { name = "packaging" },
-    { name = "pandas" },
-    { name = "pillow" },
-    { name = "pydantic" },
-    { name = "pydub" },
-    { name = "python-multipart" },
-    { name = "pyyaml" },
-    { name = "ruff", marker = "sys_platform != 'emscripten'" },
-    { name = "safehttpx" },
-    { name = "semantic-version" },
-    { name = "starlette", marker = "sys_platform != 'emscripten'" },
-    { name = "tomlkit" },
-    { name = "typer", marker = "sys_platform != 'emscripten'" },
-    { name = "typing-extensions" },
-    { name = "urllib3", marker = "sys_platform == 'emscripten'" },
-    { name = "uvicorn", marker = "sys_platform != 'emscripten'" },
-]
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/3a/1b/bd78e5d128589f28dfe76ddd587702489fabb58bdd3fbc6d09b16e5d948a/gradio-5.16.2-py3-none-any.whl", hash = "sha256:b13180c9a0a7370bdda6a326d85f659768ba97a822a7d5790b52ae4c6bccc343", size = 62206160 },
-]
-
-[[package]]
-name = "gradio-client"
-version = "1.7.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "fsspec" },
-    { name = "httpx" },
-    { name = "huggingface-hub" },
-    { name = "packaging" },
-    { name = "typing-extensions" },
-    { name = "websockets" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f2/98/434f4eff6eabf625e71ac69a5909864984b53b2f2c9e3a9c772bebbfae84/gradio_client-1.7.1.tar.gz", hash = "sha256:6ecd3a537c6c076cb1b351c2d7ce5906070d2e1b3181163609bfa4a4c4f3040e", size = 320142 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/16/52/4fe9dfc2239e7b748ad8dc3b80ad8755f5c9378432715193586c3ab74bf9/gradio_client-1.7.1-py3-none-any.whl", hash = "sha256:d7737bc473a2093549c06004379c42f0a3510a98095cf7cea9033837e252149f", size = 321994 },
-]
-
-[[package]]
-name = "gradio-rangeslider"
-version = "0.0.8"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "gradio" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/88/93/aa1723076cc1056279e43f46d804f663c794f2e098c0650d150b46372f62/gradio_rangeslider-0.0.8.tar.gz", hash = "sha256:414fd4b093d4327cc86c51b4e81e53df19664023f95bed95e3ecc03071fa1ea0", size = 1263683 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/54/44/14f759678a76ffbd6e3fe8852a4f758bc5ad51b379c67b5d167cfde752f6/gradio_rangeslider-0.0.8-py3-none-any.whl", hash = "sha256:3728c44e58ec1bff0bdf236cc84f12b183fbd596fb4714d8b797585a0515f89e", size = 1224388 },
-]
-
 [[package]]
 name = "h11"
 version = "0.14.0"
@@ -969,12 +844,10 @@ name = "languagebench"
 version = "0.1.0"
 source = { virtual = "." }
 dependencies = [
-    { name = "gradio" },
-    { name = "gradio-rangeslider" },
-    { name = "language-data" },
+    { name = "fastapi" },
+    { name = "numpy" },
     { name = "pandas" },
-    { name = "plotly" },
-    { name = "pycountry" },
+    { name = "uvicorn" },
 ]
 
 [package.dev-dependencies]
@@ -987,6 +860,7 @@ dev = [
     { name = "jiwer" },
     { name = "joblib" },
     { name = "langcodes" },
+    { name = "language-data" },
     { name = "openai" },
     { name = "protobuf" },
     { name = "python-dotenv" },
@@ -999,12 +873,10 @@ dev = [
 
 [package.metadata]
 requires-dist = [
-    { name = "gradio", specifier = ">=5.16.2" },
-    { name = "gradio-rangeslider", specifier = ">=0.0.8" },
-    { name = "language-data", specifier = ">=1.3.0" },
+    { name = "fastapi", specifier = ">=0.115.8" },
+    { name = "numpy", specifier = ">=2.1.2" },
     { name = "pandas", specifier = ">=2.2.3" },
-    { name = "plotly", specifier = ">=6.0.0" },
-    { name = "pycountry", specifier = ">=24.6.1" },
+    { name = "uvicorn", specifier = ">=0.34.0" },
 ]
 
 [package.metadata.requires-dev]
@@ -1017,6 +889,7 @@ dev = [
     { name = "jiwer", specifier = ">=3.1.0" },
     { name = "joblib", specifier = ">=1.4.2" },
     { name = "langcodes", specifier = ">=3.5.0" },
+    { name = "language-data", specifier = ">=1.3.0" },
     { name = "openai", specifier = ">=1.52.2" },
     { name = "protobuf", specifier = ">=5.28.3" },
     { name = "python-dotenv", specifier = ">=1.0.1" },
@@ -1164,18 +1037,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/27/40/5f9eb8b73030cc4b0d6817176e66079a62a2ddd9d5530da54f8011473428/marisa_trie-1.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:aa7cd17e1c690ce96c538b2f4aae003d9a498e65067dd433c52dd069009951d4", size = 149035 },
 ]
 
-[[package]]
-name = "markdown-it-py"
-version = "3.0.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "mdurl" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528 },
-]
-
 [[package]]
 name = "markupsafe"
 version = "2.1.5"
@@ -1262,15 +1123,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/01/8a/760f7fce66b39f447ad160800619d0bd5d0936d2b4633587116534a4afe0/matplotlib-3.9.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5816b1e1fe8c192cbc013f8f3e3368ac56fbecf02fb41b8f8559303f24c5015e", size = 9093770 },
 ]
 
-[[package]]
-name = "mdurl"
-version = "0.1.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979 },
-]
-
 [[package]]
 name = "mpmath"
 version = "1.3.0"
@@ -1370,15 +1222,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/da/d9/f7f9379981e39b8c2511c9e0326d212accacb82f12fbfdc1aa2ce2a7b2b6/multiprocess-0.70.16-py39-none-any.whl", hash = "sha256:a0bafd3ae1b732eac64be2e72038231c1ba97724b60b09400d68f229fcc2fbf3", size = 133351 },
 ]
 
-[[package]]
-name = "narwhals"
-version = "1.27.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/5a/d6/1dadff863b95e4ec74eaba7979278e446699532136c74183a398778b1949/narwhals-1.27.1.tar.gz", hash = "sha256:68505d0cee1e6c00382ac8b65e922f8b694a11cbe482a057fa63139de8d0ea03", size = 251670 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/ed/ea/dc14822a0a75e027562f081eb638417b1b7845e1e01dd85c5b6573ebf1b2/narwhals-1.27.1-py3-none-any.whl", hash = "sha256:71e4a126007886e3dd9d71d0d5921ebd2e8c1f9be9c405fe11850ece2b066c59", size = 308837 },
-]
-
 [[package]]
 name = "networkx"
 version = "3.4.2"
@@ -1587,66 +1430,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/55/4c/906b5b32c4c01402ac3b4c3fc28f601443ac5c6f13c84a95dd178c8d545d/openai-1.52.2-py3-none-any.whl", hash = "sha256:57e9e37bc407f39bb6ec3a27d7e8fb9728b2779936daa1fcf95df17d3edfaccc", size = 386947 },
 ]
 
-[[package]]
-name = "orjson"
-version = "3.10.15"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ae/f9/5dea21763eeff8c1590076918a446ea3d6140743e0e36f58f369928ed0f4/orjson-3.10.15.tar.gz", hash = "sha256:05ca7fe452a2e9d8d9d706a2984c95b9c2ebc5db417ce0b7a49b91d50642a23e", size = 5282482 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/52/09/e5ff18ad009e6f97eb7edc5f67ef98b3ce0c189da9c3eaca1f9587cd4c61/orjson-3.10.15-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:552c883d03ad185f720d0c09583ebde257e41b9521b74ff40e08b7dec4559c04", size = 249532 },
-    { url = "https://files.pythonhosted.org/packages/bd/b8/a75883301fe332bd433d9b0ded7d2bb706ccac679602c3516984f8814fb5/orjson-3.10.15-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:616e3e8d438d02e4854f70bfdc03a6bcdb697358dbaa6bcd19cbe24d24ece1f8", size = 125229 },
-    { url = "https://files.pythonhosted.org/packages/83/4b/22f053e7a364cc9c685be203b1e40fc5f2b3f164a9b2284547504eec682e/orjson-3.10.15-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7c2c79fa308e6edb0ffab0a31fd75a7841bf2a79a20ef08a3c6e3b26814c8ca8", size = 150148 },
-    { url = "https://files.pythonhosted.org/packages/63/64/1b54fc75ca328b57dd810541a4035fe48c12a161d466e3cf5b11a8c25649/orjson-3.10.15-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:73cb85490aa6bf98abd20607ab5c8324c0acb48d6da7863a51be48505646c814", size = 139748 },
-    { url = "https://files.pythonhosted.org/packages/5e/ff/ff0c5da781807bb0a5acd789d9a7fbcb57f7b0c6e1916595da1f5ce69f3c/orjson-3.10.15-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:763dadac05e4e9d2bc14938a45a2d0560549561287d41c465d3c58aec818b164", size = 154559 },
-    { url = "https://files.pythonhosted.org/packages/4e/9a/11e2974383384ace8495810d4a2ebef5f55aacfc97b333b65e789c9d362d/orjson-3.10.15-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a330b9b4734f09a623f74a7490db713695e13b67c959713b78369f26b3dee6bf", size = 130349 },
-    { url = "https://files.pythonhosted.org/packages/2d/c4/dd9583aea6aefee1b64d3aed13f51d2aadb014028bc929fe52936ec5091f/orjson-3.10.15-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a61a4622b7ff861f019974f73d8165be1bd9a0855e1cad18ee167acacabeb061", size = 138514 },
-    { url = "https://files.pythonhosted.org/packages/53/3e/dcf1729230654f5c5594fc752de1f43dcf67e055ac0d300c8cdb1309269a/orjson-3.10.15-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:acd271247691574416b3228db667b84775c497b245fa275c6ab90dc1ffbbd2b3", size = 130940 },
-    { url = "https://files.pythonhosted.org/packages/e8/2b/b9759fe704789937705c8a56a03f6c03e50dff7df87d65cba9a20fec5282/orjson-3.10.15-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:e4759b109c37f635aa5c5cc93a1b26927bfde24b254bcc0e1149a9fada253d2d", size = 414713 },
-    { url = "https://files.pythonhosted.org/packages/a7/6b/b9dfdbd4b6e20a59238319eb203ae07c3f6abf07eef909169b7a37ae3bba/orjson-3.10.15-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:9e992fd5cfb8b9f00bfad2fd7a05a4299db2bbe92e6440d9dd2fab27655b3182", size = 141028 },
-    { url = "https://files.pythonhosted.org/packages/7c/b5/40f5bbea619c7caf75eb4d652a9821875a8ed04acc45fe3d3ef054ca69fb/orjson-3.10.15-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f95fb363d79366af56c3f26b71df40b9a583b07bbaaf5b317407c4d58497852e", size = 129715 },
-    { url = "https://files.pythonhosted.org/packages/38/60/2272514061cbdf4d672edbca6e59c7e01cd1c706e881427d88f3c3e79761/orjson-3.10.15-cp310-cp310-win32.whl", hash = "sha256:f9875f5fea7492da8ec2444839dcc439b0ef298978f311103d0b7dfd775898ab", size = 142473 },
-    { url = "https://files.pythonhosted.org/packages/11/5d/be1490ff7eafe7fef890eb4527cf5bcd8cfd6117f3efe42a3249ec847b60/orjson-3.10.15-cp310-cp310-win_amd64.whl", hash = "sha256:17085a6aa91e1cd70ca8533989a18b5433e15d29c574582f76f821737c8d5806", size = 133564 },
-    { url = "https://files.pythonhosted.org/packages/7a/a2/21b25ce4a2c71dbb90948ee81bd7a42b4fbfc63162e57faf83157d5540ae/orjson-3.10.15-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:c4cc83960ab79a4031f3119cc4b1a1c627a3dc09df125b27c4201dff2af7eaa6", size = 249533 },
-    { url = "https://files.pythonhosted.org/packages/b2/85/2076fc12d8225698a51278009726750c9c65c846eda741e77e1761cfef33/orjson-3.10.15-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ddbeef2481d895ab8be5185f2432c334d6dec1f5d1933a9c83014d188e102cef", size = 125230 },
-    { url = "https://files.pythonhosted.org/packages/06/df/a85a7955f11274191eccf559e8481b2be74a7c6d43075d0a9506aa80284d/orjson-3.10.15-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:9e590a0477b23ecd5b0ac865b1b907b01b3c5535f5e8a8f6ab0e503efb896334", size = 150148 },
-    { url = "https://files.pythonhosted.org/packages/37/b3/94c55625a29b8767c0eed194cb000b3787e3c23b4cdd13be17bae6ccbb4b/orjson-3.10.15-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a6be38bd103d2fd9bdfa31c2720b23b5d47c6796bcb1d1b598e3924441b4298d", size = 139749 },
-    { url = "https://files.pythonhosted.org/packages/53/ba/c608b1e719971e8ddac2379f290404c2e914cf8e976369bae3cad88768b1/orjson-3.10.15-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ff4f6edb1578960ed628a3b998fa54d78d9bb3e2eb2cfc5c2a09732431c678d0", size = 154558 },
-    { url = "https://files.pythonhosted.org/packages/b2/c4/c1fb835bb23ad788a39aa9ebb8821d51b1c03588d9a9e4ca7de5b354fdd5/orjson-3.10.15-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b0482b21d0462eddd67e7fce10b89e0b6ac56570424662b685a0d6fccf581e13", size = 130349 },
-    { url = "https://files.pythonhosted.org/packages/78/14/bb2b48b26ab3c570b284eb2157d98c1ef331a8397f6c8bd983b270467f5c/orjson-3.10.15-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bb5cc3527036ae3d98b65e37b7986a918955f85332c1ee07f9d3f82f3a6899b5", size = 138513 },
-    { url = "https://files.pythonhosted.org/packages/4a/97/d5b353a5fe532e92c46467aa37e637f81af8468aa894cd77d2ec8a12f99e/orjson-3.10.15-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d569c1c462912acdd119ccbf719cf7102ea2c67dd03b99edcb1a3048651ac96b", size = 130942 },
-    { url = "https://files.pythonhosted.org/packages/b5/5d/a067bec55293cca48fea8b9928cfa84c623be0cce8141d47690e64a6ca12/orjson-3.10.15-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:1e6d33efab6b71d67f22bf2962895d3dc6f82a6273a965fab762e64fa90dc399", size = 414717 },
-    { url = "https://files.pythonhosted.org/packages/6f/9a/1485b8b05c6b4c4db172c438cf5db5dcfd10e72a9bc23c151a1137e763e0/orjson-3.10.15-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:c33be3795e299f565681d69852ac8c1bc5c84863c0b0030b2b3468843be90388", size = 141033 },
-    { url = "https://files.pythonhosted.org/packages/f8/d2/fc67523656e43a0c7eaeae9007c8b02e86076b15d591e9be11554d3d3138/orjson-3.10.15-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:eea80037b9fae5339b214f59308ef0589fc06dc870578b7cce6d71eb2096764c", size = 129720 },
-    { url = "https://files.pythonhosted.org/packages/79/42/f58c7bd4e5b54da2ce2ef0331a39ccbbaa7699b7f70206fbf06737c9ed7d/orjson-3.10.15-cp311-cp311-win32.whl", hash = "sha256:d5ac11b659fd798228a7adba3e37c010e0152b78b1982897020a8e019a94882e", size = 142473 },
-    { url = "https://files.pythonhosted.org/packages/00/f8/bb60a4644287a544ec81df1699d5b965776bc9848d9029d9f9b3402ac8bb/orjson-3.10.15-cp311-cp311-win_amd64.whl", hash = "sha256:cf45e0214c593660339ef63e875f32ddd5aa3b4adc15e662cdb80dc49e194f8e", size = 133570 },
-    { url = "https://files.pythonhosted.org/packages/66/85/22fe737188905a71afcc4bf7cc4c79cd7f5bbe9ed1fe0aac4ce4c33edc30/orjson-3.10.15-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:9d11c0714fc85bfcf36ada1179400862da3288fc785c30e8297844c867d7505a", size = 249504 },
-    { url = "https://files.pythonhosted.org/packages/48/b7/2622b29f3afebe938a0a9037e184660379797d5fd5234e5998345d7a5b43/orjson-3.10.15-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dba5a1e85d554e3897fa9fe6fbcff2ed32d55008973ec9a2b992bd9a65d2352d", size = 125080 },
-    { url = "https://files.pythonhosted.org/packages/ce/8f/0b72a48f4403d0b88b2a41450c535b3e8989e8a2d7800659a967efc7c115/orjson-3.10.15-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7723ad949a0ea502df656948ddd8b392780a5beaa4c3b5f97e525191b102fff0", size = 150121 },
-    { url = "https://files.pythonhosted.org/packages/06/ec/acb1a20cd49edb2000be5a0404cd43e3c8aad219f376ac8c60b870518c03/orjson-3.10.15-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6fd9bc64421e9fe9bd88039e7ce8e58d4fead67ca88e3a4014b143cec7684fd4", size = 139796 },
-    { url = "https://files.pythonhosted.org/packages/33/e1/f7840a2ea852114b23a52a1c0b2bea0a1ea22236efbcdb876402d799c423/orjson-3.10.15-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dadba0e7b6594216c214ef7894c4bd5f08d7c0135f4dd0145600be4fbcc16767", size = 154636 },
-    { url = "https://files.pythonhosted.org/packages/fa/da/31543337febd043b8fa80a3b67de627669b88c7b128d9ad4cc2ece005b7a/orjson-3.10.15-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b48f59114fe318f33bbaee8ebeda696d8ccc94c9e90bc27dbe72153094e26f41", size = 130621 },
-    { url = "https://files.pythonhosted.org/packages/ed/78/66115dc9afbc22496530d2139f2f4455698be444c7c2475cb48f657cefc9/orjson-3.10.15-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:035fb83585e0f15e076759b6fedaf0abb460d1765b6a36f48018a52858443514", size = 138516 },
-    { url = "https://files.pythonhosted.org/packages/22/84/cd4f5fb5427ffcf823140957a47503076184cb1ce15bcc1165125c26c46c/orjson-3.10.15-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d13b7fe322d75bf84464b075eafd8e7dd9eae05649aa2a5354cfa32f43c59f17", size = 130762 },
-    { url = "https://files.pythonhosted.org/packages/93/1f/67596b711ba9f56dd75d73b60089c5c92057f1130bb3a25a0f53fb9a583b/orjson-3.10.15-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:7066b74f9f259849629e0d04db6609db4cf5b973248f455ba5d3bd58a4daaa5b", size = 414700 },
-    { url = "https://files.pythonhosted.org/packages/7c/0c/6a3b3271b46443d90efb713c3e4fe83fa8cd71cda0d11a0f69a03f437c6e/orjson-3.10.15-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:88dc3f65a026bd3175eb157fea994fca6ac7c4c8579fc5a86fc2114ad05705b7", size = 141077 },
-    { url = "https://files.pythonhosted.org/packages/3b/9b/33c58e0bfc788995eccd0d525ecd6b84b40d7ed182dd0751cd4c1322ac62/orjson-3.10.15-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b342567e5465bd99faa559507fe45e33fc76b9fb868a63f1642c6bc0735ad02a", size = 129898 },
-    { url = "https://files.pythonhosted.org/packages/01/c1/d577ecd2e9fa393366a1ea0a9267f6510d86e6c4bb1cdfb9877104cac44c/orjson-3.10.15-cp312-cp312-win32.whl", hash = "sha256:0a4f27ea5617828e6b58922fdbec67b0aa4bb844e2d363b9244c47fa2180e665", size = 142566 },
-    { url = "https://files.pythonhosted.org/packages/ed/eb/a85317ee1732d1034b92d56f89f1de4d7bf7904f5c8fb9dcdd5b1c83917f/orjson-3.10.15-cp312-cp312-win_amd64.whl", hash = "sha256:ef5b87e7aa9545ddadd2309efe6824bd3dd64ac101c15dae0f2f597911d46eaa", size = 133732 },
-    { url = "https://files.pythonhosted.org/packages/06/10/fe7d60b8da538e8d3d3721f08c1b7bff0491e8fa4dd3bf11a17e34f4730e/orjson-3.10.15-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:bae0e6ec2b7ba6895198cd981b7cca95d1487d0147c8ed751e5632ad16f031a6", size = 249399 },
-    { url = "https://files.pythonhosted.org/packages/6b/83/52c356fd3a61abd829ae7e4366a6fe8e8863c825a60d7ac5156067516edf/orjson-3.10.15-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f93ce145b2db1252dd86af37d4165b6faa83072b46e3995ecc95d4b2301b725a", size = 125044 },
-    { url = "https://files.pythonhosted.org/packages/55/b2/d06d5901408e7ded1a74c7c20d70e3a127057a6d21355f50c90c0f337913/orjson-3.10.15-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7c203f6f969210128af3acae0ef9ea6aab9782939f45f6fe02d05958fe761ef9", size = 150066 },
-    { url = "https://files.pythonhosted.org/packages/75/8c/60c3106e08dc593a861755781c7c675a566445cc39558677d505878d879f/orjson-3.10.15-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8918719572d662e18b8af66aef699d8c21072e54b6c82a3f8f6404c1f5ccd5e0", size = 139737 },
-    { url = "https://files.pythonhosted.org/packages/6a/8c/ae00d7d0ab8a4490b1efeb01ad4ab2f1982e69cc82490bf8093407718ff5/orjson-3.10.15-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f71eae9651465dff70aa80db92586ad5b92df46a9373ee55252109bb6b703307", size = 154804 },
-    { url = "https://files.pythonhosted.org/packages/22/86/65dc69bd88b6dd254535310e97bc518aa50a39ef9c5a2a5d518e7a223710/orjson-3.10.15-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e117eb299a35f2634e25ed120c37c641398826c2f5a3d3cc39f5993b96171b9e", size = 130583 },
-    { url = "https://files.pythonhosted.org/packages/bb/00/6fe01ededb05d52be42fabb13d93a36e51f1fd9be173bd95707d11a8a860/orjson-3.10.15-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:13242f12d295e83c2955756a574ddd6741c81e5b99f2bef8ed8d53e47a01e4b7", size = 138465 },
-    { url = "https://files.pythonhosted.org/packages/db/2f/4cc151c4b471b0cdc8cb29d3eadbce5007eb0475d26fa26ed123dca93b33/orjson-3.10.15-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7946922ada8f3e0b7b958cc3eb22cfcf6c0df83d1fe5521b4a100103e3fa84c8", size = 130742 },
-    { url = "https://files.pythonhosted.org/packages/9f/13/8a6109e4b477c518498ca37963d9c0eb1508b259725553fb53d53b20e2ea/orjson-3.10.15-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:b7155eb1623347f0f22c38c9abdd738b287e39b9982e1da227503387b81b34ca", size = 414669 },
-    { url = "https://files.pythonhosted.org/packages/22/7b/1d229d6d24644ed4d0a803de1b0e2df832032d5beda7346831c78191b5b2/orjson-3.10.15-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:208beedfa807c922da4e81061dafa9c8489c6328934ca2a562efa707e049e561", size = 141043 },
-    { url = "https://files.pythonhosted.org/packages/cc/d3/6dc91156cf12ed86bed383bcb942d84d23304a1e57b7ab030bf60ea130d6/orjson-3.10.15-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:eca81f83b1b8c07449e1d6ff7074e82e3fd6777e588f1a6632127f286a968825", size = 129826 },
-    { url = "https://files.pythonhosted.org/packages/b3/38/c47c25b86f6996f1343be721b6ea4367bc1c8bc0fc3f6bbcd995d18cb19d/orjson-3.10.15-cp313-cp313-win32.whl", hash = "sha256:c03cd6eea1bd3b949d0d007c8d57049aa2b39bd49f58b4b2af571a5d3833d890", size = 142542 },
-    { url = "https://files.pythonhosted.org/packages/27/f1/1d7ec15b20f8ce9300bc850de1e059132b88990e46cd0ccac29cbf11e4f9/orjson-3.10.15-cp313-cp313-win_amd64.whl", hash = "sha256:fd56a26a04f6ba5fb2045b0acc487a63162a958ed837648c5781e1fe3316cfbf", size = 133444 },
-]
-
 [[package]]
 name = "packaging"
 version = "24.1"
@@ -1771,19 +1554,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/ec/3d/c32a51d848401bd94cabb8767a39621496491ee7cd5199856b77da9b18ad/pillow-11.0.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:224aaa38177597bb179f3ec87eeefcce8e4f85e608025e9cfac60de237ba6316", size = 2567508 },
 ]
 
-[[package]]
-name = "plotly"
-version = "6.0.0"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "narwhals" },
-    { name = "packaging" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/9c/80/761c14012d6daf18e12b6d1e4f6b218e999bcceb694d7a9b180154f9e4db/plotly-6.0.0.tar.gz", hash = "sha256:c4aad38b8c3d65e4a5e7dd308b084143b9025c2cc9d5317fc1f1d30958db87d3", size = 8111782 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/0e/77/a946f38b57fb88e736c71fbdd737a1aebd27b532bda0779c137f357cf5fc/plotly-6.0.0-py3-none-any.whl", hash = "sha256:f708871c3a9349a68791ff943a5781b1ec04de7769ea69068adcd9202e57653a", size = 14805949 },
-]
-
 [[package]]
 name = "portalocker"
 version = "2.10.1"
@@ -1925,15 +1695,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/92/a2/81c1dd744b322c0c548f793deb521bf23500806d754128ddf6f978736dff/pyarrow-18.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:b46591222c864e7da7faa3b19455196416cd8355ff6c2cc2e65726a760a3c420", size = 40006508 },
 ]
 
-[[package]]
-name = "pycountry"
-version = "24.6.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/76/57/c389fa68c50590881a75b7883eeb3dc15e9e73a0fdc001cdd45c13290c92/pycountry-24.6.1.tar.gz", hash = "sha256:b61b3faccea67f87d10c1f2b0fc0be714409e8fcdcc1315613174f6466c10221", size = 6043910 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b1/ec/1fb891d8a2660716aadb2143235481d15ed1cbfe3ad669194690b0604492/pycountry-24.6.1-py3-none-any.whl", hash = "sha256:f1a4fb391cd7214f8eefd39556d740adcc233c778a27f8942c8dca351d6ce06f", size = 6335189 },
-]
-
 [[package]]
 name = "pydantic"
 version = "2.9.2"
@@ -2015,24 +1776,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/a9/f9/b6bcaf874f410564a78908739c80861a171788ef4d4f76f5009656672dfe/pydantic_core-2.23.4-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:9a5bce9d23aac8f0cf0836ecfc033896aa8443b501c58d0602dbfd5bd5b37753", size = 1920344 },
 ]
 
-[[package]]
-name = "pydub"
-version = "0.25.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/fe/9a/e6bca0eed82db26562c73b5076539a4a08d3cffd19c3cc5913a3e61145fd/pydub-0.25.1.tar.gz", hash = "sha256:980a33ce9949cab2a569606b65674d748ecbca4f0796887fd6f46173a7b0d30f", size = 38326 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a6/53/d78dc063216e62fc55f6b2eebb447f6a4b0a59f55c8406376f76bf959b08/pydub-0.25.1-py2.py3-none-any.whl", hash = "sha256:65617e33033874b59d87db603aa1ed450633288aefead953b30bded59cb599a6", size = 32327 },
-]
-
-[[package]]
-name = "pygments"
-version = "2.19.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/7c/2d/c3338d48ea6cc0feb8446d8e6937e1408088a72a39937982cc6111d17f84/pygments-2.19.1.tar.gz", hash = "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f", size = 4968581 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/8a/0b/9fcc47d19c48b59121088dd6da2488a49d5f72dacf8262e2790a1d2c7d15/pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c", size = 1225293 },
-]
-
 [[package]]
 name = "pyparsing"
 version = "3.2.0"
@@ -2063,15 +1806,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/6a/3e/b68c118422ec867fa7ab88444e1274aa40681c606d59ac27de5a5588f082/python_dotenv-1.0.1-py3-none-any.whl", hash = "sha256:f7b63ef50f1b690dddf550d03497b66d609393b40b564ed0d674909a68ebf16a", size = 19863 },
 ]
 
-[[package]]
-name = "python-multipart"
-version = "0.0.20"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f3/87/f44d7c9f274c7ee665a29b885ec97089ec5dc034c7f3fafa03da9e39a09e/python_multipart-0.0.20.tar.gz", hash = "sha256:8dd0cab45b8e23064ae09147625994d090fa46f5b0d1e13af944c331a7fa9d13", size = 37158 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/45/58/38b5afbc1a800eeea951b9285d3912613f2603bdf897a4ab0f4bd7f405fc/python_multipart-0.0.20-py3-none-any.whl", hash = "sha256:8a62d3a8335e06589fe01f2a3e178cdcc632f3fbe0d492ad9ee0ec35aab1f104", size = 24546 },
-]
-
 [[package]]
 name = "pytz"
 version = "2024.2"
@@ -2321,45 +2055,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/79/f3/2b3a6dc5986303b3dd1bbbcf482022acb2583c428cd23f0b6d37b1a1a519/responses-0.18.0-py3-none-any.whl", hash = "sha256:15c63ad16de13ee8e7182d99c9334f64fd81f1ee79f90748d527c28f7ca9dd51", size = 38735 },
 ]
 
-[[package]]
-name = "rich"
-version = "13.9.4"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "markdown-it-py" },
-    { name = "pygments" },
-    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", hash = "sha256:439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098", size = 223149 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", hash = "sha256:6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90", size = 242424 },
-]
-
-[[package]]
-name = "ruff"
-version = "0.9.7"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/39/8b/a86c300359861b186f18359adf4437ac8e4c52e42daa9eedc731ef9d5b53/ruff-0.9.7.tar.gz", hash = "sha256:643757633417907510157b206e490c3aa11cab0c087c912f60e07fbafa87a4c6", size = 3669813 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b1/f3/3a1d22973291226df4b4e2ff70196b926b6f910c488479adb0eeb42a0d7f/ruff-0.9.7-py3-none-linux_armv6l.whl", hash = "sha256:99d50def47305fe6f233eb8dabfd60047578ca87c9dcb235c9723ab1175180f4", size = 11774588 },
-    { url = "https://files.pythonhosted.org/packages/8e/c9/b881f4157b9b884f2994fd08ee92ae3663fb24e34b0372ac3af999aa7fc6/ruff-0.9.7-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:d59105ae9c44152c3d40a9c40d6331a7acd1cdf5ef404fbe31178a77b174ea66", size = 11746848 },
-    { url = "https://files.pythonhosted.org/packages/14/89/2f546c133f73886ed50a3d449e6bf4af27d92d2f960a43a93d89353f0945/ruff-0.9.7-py3-none-macosx_11_0_arm64.whl", hash = "sha256:f313b5800483770bd540cddac7c90fc46f895f427b7820f18fe1822697f1fec9", size = 11177525 },
-    { url = "https://files.pythonhosted.org/packages/d7/93/6b98f2c12bf28ab9def59c50c9c49508519c5b5cfecca6de871cf01237f6/ruff-0.9.7-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:042ae32b41343888f59c0a4148f103208bf6b21c90118d51dc93a68366f4e903", size = 11996580 },
-    { url = "https://files.pythonhosted.org/packages/8e/3f/b3fcaf4f6d875e679ac2b71a72f6691a8128ea3cb7be07cbb249f477c061/ruff-0.9.7-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:87862589373b33cc484b10831004e5e5ec47dc10d2b41ba770e837d4f429d721", size = 11525674 },
-    { url = "https://files.pythonhosted.org/packages/f0/48/33fbf18defb74d624535d5d22adcb09a64c9bbabfa755bc666189a6b2210/ruff-0.9.7-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a17e1e01bee0926d351a1ee9bc15c445beae888f90069a6192a07a84af544b6b", size = 12739151 },
-    { url = "https://files.pythonhosted.org/packages/63/b5/7e161080c5e19fa69495cbab7c00975ef8a90f3679caa6164921d7f52f4a/ruff-0.9.7-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:7c1f880ac5b2cbebd58b8ebde57069a374865c73f3bf41f05fe7a179c1c8ef22", size = 13416128 },
-    { url = "https://files.pythonhosted.org/packages/4e/c8/b5e7d61fb1c1b26f271ac301ff6d9de5e4d9a9a63f67d732fa8f200f0c88/ruff-0.9.7-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e63fc20143c291cab2841dbb8260e96bafbe1ba13fd3d60d28be2c71e312da49", size = 12870858 },
-    { url = "https://files.pythonhosted.org/packages/da/cb/2a1a8e4e291a54d28259f8fc6a674cd5b8833e93852c7ef5de436d6ed729/ruff-0.9.7-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:91ff963baed3e9a6a4eba2a02f4ca8eaa6eba1cc0521aec0987da8d62f53cbef", size = 14786046 },
-    { url = "https://files.pythonhosted.org/packages/ca/6c/c8f8a313be1943f333f376d79724260da5701426c0905762e3ddb389e3f4/ruff-0.9.7-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88362e3227c82f63eaebf0b2eff5b88990280fb1ecf7105523883ba8c3aaf6fb", size = 12550834 },
-    { url = "https://files.pythonhosted.org/packages/9d/ad/f70cf5e8e7c52a25e166bdc84c082163c9c6f82a073f654c321b4dff9660/ruff-0.9.7-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:0372c5a90349f00212270421fe91874b866fd3626eb3b397ede06cd385f6f7e0", size = 11961307 },
-    { url = "https://files.pythonhosted.org/packages/52/d5/4f303ea94a5f4f454daf4d02671b1fbfe2a318b5fcd009f957466f936c50/ruff-0.9.7-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:d76b8ab60e99e6424cd9d3d923274a1324aefce04f8ea537136b8398bbae0a62", size = 11612039 },
-    { url = "https://files.pythonhosted.org/packages/eb/c8/bd12a23a75603c704ce86723be0648ba3d4ecc2af07eecd2e9fa112f7e19/ruff-0.9.7-py3-none-musllinux_1_2_i686.whl", hash = "sha256:0c439bdfc8983e1336577f00e09a4e7a78944fe01e4ea7fe616d00c3ec69a3d0", size = 12168177 },
-    { url = "https://files.pythonhosted.org/packages/cc/57/d648d4f73400fef047d62d464d1a14591f2e6b3d4a15e93e23a53c20705d/ruff-0.9.7-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:115d1f15e8fdd445a7b4dc9a30abae22de3f6bcabeb503964904471691ef7606", size = 12610122 },
-    { url = "https://files.pythonhosted.org/packages/49/79/acbc1edd03ac0e2a04ae2593555dbc9990b34090a9729a0c4c0cf20fb595/ruff-0.9.7-py3-none-win32.whl", hash = "sha256:e9ece95b7de5923cbf38893f066ed2872be2f2f477ba94f826c8defdd6ec6b7d", size = 9988751 },
-    { url = "https://files.pythonhosted.org/packages/6d/95/67153a838c6b6ba7a2401241fd8a00cd8c627a8e4a0491b8d853dedeffe0/ruff-0.9.7-py3-none-win_amd64.whl", hash = "sha256:3770fe52b9d691a15f0b87ada29c45324b2ace8f01200fb0c14845e499eb0c2c", size = 11002987 },
-    { url = "https://files.pythonhosted.org/packages/63/6a/aca01554949f3a401991dc32fe22837baeaccb8a0d868256cbb26a029778/ruff-0.9.7-py3-none-win_arm64.whl", hash = "sha256:b075a700b2533feb7a01130ff656a4ec0d5f340bb540ad98759b8401c32c2037", size = 10177763 },
-]
-
 [[package]]
 name = "sacrebleu"
 version = "2.4.3"
@@ -2377,18 +2072,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/15/d8/e51d35bc863caa19ddeae48dfb890581a19326973ad1c9fa5dcfc63310f7/sacrebleu-2.4.3-py3-none-any.whl", hash = "sha256:a976fd6998d8ced267a722120ec7fc47083c8e9745d8808ccee6424464a0aa31", size = 103964 },
 ]
 
-[[package]]
-name = "safehttpx"
-version = "0.1.6"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "httpx" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/67/4c/19db75e6405692b2a96af8f06d1258f8aa7290bdc35ac966f03e207f6d7f/safehttpx-0.1.6.tar.gz", hash = "sha256:b356bfc82cee3a24c395b94a2dbeabbed60aff1aa5fa3b5fe97c4f2456ebce42", size = 9987 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/4d/c0/1108ad9f01567f66b3154063605b350b69c3c9366732e09e45f9fd0d1deb/safehttpx-0.1.6-py3-none-any.whl", hash = "sha256:407cff0b410b071623087c63dd2080c3b44dc076888d8c5823c00d1e58cb381c", size = 8692 },
-]
-
 [[package]]
 name = "safetensors"
 version = "0.4.5"
@@ -2450,15 +2133,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/19/46/5d11dc300feaad285c2f1bd784ff3f689f5e0ab6be49aaf568f3a77019eb/safetensors-0.4.5-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:21742b391b859e67b26c0b2ac37f52c9c0944a879a25ad2f9f9f3cd61e7fda8f", size = 606660 },
 ]
 
-[[package]]
-name = "semantic-version"
-version = "2.10.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/7d/31/f2289ce78b9b473d582568c234e104d2a342fd658cc288a7553d83bb8595/semantic_version-2.10.0.tar.gz", hash = "sha256:bdabb6d336998cbb378d4b9db3a4b56a1e3235701dc05ea2690d9a997ed5041c", size = 52289 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/6a/23/8146aad7d88f4fcb3a6218f41a60f6c2d4e3a72de72da1825dc7c8f7877c/semantic_version-2.10.0-py2.py3-none-any.whl", hash = "sha256:de78a3b8e0feda74cabc54aab2da702113e33ac9d9eb9d2389bcf1f58b7d9177", size = 15552 },
-]
-
 [[package]]
 name = "sentencepiece"
 version = "0.2.0"
@@ -2500,15 +2174,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/90/12/282ee9bce8b58130cb762fbc9beabd531549952cac11fc56add11dcb7ea0/setuptools-75.3.0-py3-none-any.whl", hash = "sha256:f2504966861356aa38616760c0f66568e535562374995367b4e69c7143cf6bcd", size = 1251070 },
 ]
 
-[[package]]
-name = "shellingham"
-version = "1.5.4"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/58/15/8b3609fd3830ef7b27b655beb4b4e9c62313a4e8da8c676e142cc210d58e/shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de", size = 10310 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e0/f9/0595336914c5619e5f28a1fb793285925a8cd4b432c9da0a987836c7f822/shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686", size = 9755 },
-]
-
 [[package]]
 name = "six"
 version = "1.16.0"
@@ -2650,15 +2315,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/d4/f2/ea998aaf69966a87f92e31db7cba887125994bb9cd9a4dfcc83ac202d446/tokenizers-0.20.1-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:f40df5e0294a95131cc5f0e0eb91fe86d88837abfbee46b9b3610b09860195a7", size = 9300207 },
 ]
 
-[[package]]
-name = "tomlkit"
-version = "0.13.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b1/09/a439bec5888f00a54b8b9f05fa94d7f901d6735ef4e55dcec9bc37b5d8fa/tomlkit-0.13.2.tar.gz", hash = "sha256:fff5fe59a87295b278abd31bec92c15d9bc4a06885ab12bcea52c71119392e79", size = 192885 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/f9/b6/a447b5e4ec71e13871be01ba81f5dfc9d0af7e473da256ff46bc0e24026f/tomlkit-0.13.2-py3-none-any.whl", hash = "sha256:7a974427f6e119197f670fbbbeae7bef749a6c14e793db934baefc1b5f03efde", size = 37955 },
-]
-
 [[package]]
 name = "torch"
 version = "2.5.1"
@@ -2747,21 +2403,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/78/eb/65f5ba83c2a123f6498a3097746607e5b2f16add29e36765305e4ac7fdd8/triton-3.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c8182f42fd8080a7d39d666814fa36c5e30cc00ea7eeeb1a2983dbb4c99a0fdc", size = 209551444 },
 ]
 
-[[package]]
-name = "typer"
-version = "0.15.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "click" },
-    { name = "rich" },
-    { name = "shellingham" },
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/cb/ce/dca7b219718afd37a0068f4f2530a727c2b74a8b6e8e0c0080a4c0de4fcd/typer-0.15.1.tar.gz", hash = "sha256:a0588c0a7fa68a1978a069818657778f86abe6ff5ea6abf472f940a08bfe4f0a", size = 99789 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/d0/cc/0a838ba5ca64dc832aa43f727bd586309846b0ffb2ce52422543e6075e8a/typer-0.15.1-py3-none-any.whl", hash = "sha256:7994fb7b8155b64d3402518560648446072864beefd44aa2dc36972a5972e847", size = 44908 },
-]
-
 [[package]]
 name = "typing-extensions"
 version = "4.12.2"