github_metrics/main.py

import gradio as gr
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go
from scipy.stats import mannwhitneyu
from termcolor import colored
from utils import load_all_developers_dataset


def process_input(input_text, uploaded_file, program_end_date=None, event_name=None):
    try:
        print(colored("Processing input...", "blue"))
        if uploaded_file is not None:
            print(colored("Reading from uploaded file...", "blue"))
            file_content = uploaded_file.decode("utf-8")
            github_handles = [
                handle.strip() for handle in file_content.split("\n") if handle.strip()
            ]
        else:
            github_handles = [handle.strip() for handle in input_text.split(",")]
        print(colored(f"GitHub handles: {github_handles}", "blue"))

        if program_end_date == "":
            program_end_date = None

        df = load_all_developers_dataset()
        print(colored("Filtering dataset...", "blue"))
        one_year_ago = pd.Timestamp.now() - pd.DateOffset(years=1)
        filtered_df = df[
            (df["developer"].isin(github_handles)) & (df["month_year"] >= one_year_ago)
        ]
        filtered_df = filtered_df.sort_values(by=["developer", "month_year"])
        filtered_df.loc[:, "month_year"] = pd.to_datetime(filtered_df["month_year"])

        line_fig = create_line_plot(filtered_df, github_handles, program_end_date)

        # Debug
        # print(colored("Debugging filtered dataset and github handles...", "blue"))
        # print(filtered_df.head(100))
        # print(filtered_df["developer"].unique())
        # print(github_handles)
        filtered_df.to_csv("debug.csv", index=False)
        # Debug

        analysis_result = perform_statistical_analysis(
            filtered_df, github_handles, program_end_date
        )

        new_developers_count = count_new_developers(
            filtered_df, github_handles, program_end_date
        )

        last_3_months = pd.Timestamp.now() - pd.DateOffset(months=3)
        recent_activity_user = filtered_df[filtered_df["month_year"] >= last_3_months]
        all_devs_df = load_all_developers_dataset()
        all_devs_filtered_df = all_devs_df[(all_devs_df["month_year"] >= last_3_months)]
        other_devs_recent_activity = all_devs_filtered_df[
            ~all_devs_filtered_df["developer"].isin(github_handles)
        ]

        user_specified_active = recent_activity_user[
            recent_activity_user["total_commits"] > 0
        ]
        other_developers_active = other_devs_recent_activity[
            other_devs_recent_activity["total_commits"] > 0
        ]

        box_fig = create_box_plot(user_specified_active, other_developers_active)

        print(colored("Classifying developers...", "blue"))
        classification_df = classify_developers(github_handles, recent_activity_user)
        print(colored("Classification completed.", "blue"))

        comparison_result = compare_user_developers_to_others(
            user_specified_active, other_developers_active, df, program_end_date
        )

        growth_rate_result = compare_growth_rate(
            user_specified_active, other_developers_active, df
        )

        tldr_summary = generate_tldr_summary(
            github_handles,
            classification_df,
            analysis_result,
            new_developers_count,
            comparison_result,
            growth_rate_result,
            event_name,
        )

        return (
            line_fig,
            box_fig,
            classification_df,
            analysis_result,
            new_developers_count,
            comparison_result,
            growth_rate_result,
            tldr_summary,
        )
    except Exception as e:
        print(colored(f"Error processing input: {e}", "red"))
        return (
            None,
            None,
            None,
            None,
            "Error in processing input. Check logs for more details on the error",
            None,
            None,
            "Error in processing input. Check logs for more details on the error",
        )


def create_line_plot(filtered_df, github_handles, program_end_date):
    all_developers = pd.DataFrame(
        {
            "developer": github_handles,
            "month_year": pd.Timestamp.now(),
            "total_commits": 0,
        }
    )
    plot_df = pd.concat([filtered_df, all_developers])
    plot_df = (
        plot_df.groupby(["developer", "month_year"])["total_commits"]
        .sum()
        .reset_index()
    )
    line_fig = px.line(
        plot_df,
        x="month_year",
        y="total_commits",
        color="developer",
        labels={"month_year": "Month", "total_commits": "Number of Commits"},
        title="Commits per Month",
    )
    if program_end_date:
        program_end_date = pd.to_datetime(program_end_date)
        line_fig.add_vline(
            x=program_end_date, line_width=2, line_dash="dash", line_color="red"
        )
    return line_fig


def create_box_plot(user_specified_active, other_developers_active):
    box_fig = go.Figure()
    box_fig.add_trace(
        go.Box(
            y=user_specified_active["total_commits"], name="User Specified Developers"
        )
    )
    box_fig.add_trace(
        go.Box(y=other_developers_active["total_commits"], name="Other Developers")
    )
    box_fig.update_layout(
        title="Comparison of Monthly Commits in the Last 3 Months: User Specified vs. Other Developers (Active Only)",
        yaxis_title="Total Monthly Commits",
        yaxis=dict(range=[0, 50]),
    )
    return box_fig


def classify_developers(github_handles, recent_activity_user):
    classification = []
    for handle in github_handles:
        dev_df = recent_activity_user[recent_activity_user["developer"] == handle]
        total_recent_commits = dev_df["total_commits"].sum()
        if dev_df.empty or total_recent_commits == 0:
            status = "Always been inactive"
        elif total_recent_commits < 20:
            status = "Low-level active"
        else:
            status = "Highly involved"
        classification.append((handle, status, total_recent_commits))

    sort_keys = {
        "Highly involved": 1,
        "Low-level active": 2,
        "Previously active but no longer": 3,
        "Always been inactive": 4,
    }
    classification_df = pd.DataFrame(
        classification, columns=["Developer", "Classification", "Total Recent Commits"]
    )
    classification_df["Sort Key"] = classification_df["Classification"].map(sort_keys)
    classification_df.sort_values(
        by=["Sort Key", "Total Recent Commits"], ascending=[True, False], inplace=True
    )
    classification_df.drop(["Sort Key", "Total Recent Commits"], axis=1, inplace=True)
    return classification_df


def perform_statistical_analysis(filtered_df, github_handles, program_end_date_str):
    if program_end_date_str is None:
        return "Program end date not provided. Unable to perform statistical analysis."

    program_end_date = pd.to_datetime(program_end_date_str)
    before_program = filtered_df[filtered_df["month_year"] < program_end_date]
    after_program = filtered_df[filtered_df["month_year"] >= program_end_date]

    before_counts = before_program.groupby("developer")["total_commits"].median()
    after_counts = after_program.groupby("developer")["total_commits"].median()

    all_developers = pd.Series(0, index=github_handles)
    before_counts = before_counts.reindex(all_developers.index, fill_value=0)
    after_counts = after_counts.reindex(all_developers.index, fill_value=0)

    if (before_counts == 0).all() or (after_counts == 0).all():
        return "Not enough data for statistical analysis. All values are zero in either before or after counts."

    stat, p_value = mannwhitneyu(after_counts, before_counts)
    analysis_result = (
        f"Mann-Whitney U test statistic: {stat:.3f}, P-value: {p_value:.3f}\n"
    )

    if p_value < 0.2:
        if stat > 0:
            analysis_result += (
                "Difference in commit activity before and after the program is considered significant. "
                "The commit activity is higher after the program."
            )
        else:
            analysis_result += (
                "Difference in commit activity before and after the program is considered significant. "
                "The commit activity is lower after the program."
            )
    else:
        analysis_result += (
            "No significant difference in commit activity before and after the program."
        )

    return analysis_result


def count_new_developers(filtered_df, github_handles, program_end_date_str):
    if program_end_date_str is None:
        print(
            colored(
                "Program end date not provided. Unable to count new developers. No problem.",
                "yellow",
            )
        )
        return (
            "Program end date not provided. Unable to count new developers. No problem."
        )

    program_end_date = pd.to_datetime(program_end_date_str)
    two_months_after_program = program_end_date + pd.DateOffset(months=2)

    before_program = filtered_df[filtered_df["month_year"] < program_end_date]
    after_program = filtered_df[
        (filtered_df["month_year"] >= program_end_date)
        & (filtered_df["month_year"] <= two_months_after_program)
    ]

    before_developers = before_program["developer"].unique()
    after_developers = after_program["developer"].unique()

    new_developers = set(after_developers) - set(before_developers)
    new_developers_str = ", ".join(new_developers)

    return f"Number of new developers committing code within 2 months after the program: {len(new_developers)}\nNew developers: {new_developers_str}"


def compare_user_developers_to_others(
    user_specified_active, other_developers_active, df, program_end_date_str
):
    if program_end_date_str is None:
        print(
            colored(
                "Program end date not provided. Unable to compare user-specified developers to others. No problem.",
                "yellow",
            )
        )
        return "Program end date not provided. Unable to compare user-specified developers to others. No problem."

    program_end_date = pd.to_datetime(program_end_date_str)
    user_commits = df[
        (df["developer"].isin(user_specified_active["developer"]))
        & (df["month_year"] >= program_end_date)
    ]["total_commits"]
    other_commits = df[
        (df["developer"].isin(other_developers_active["developer"]))
        & (df["month_year"] >= program_end_date)
    ]["total_commits"]

    if len(user_commits) == 0 or len(other_commits) == 0:
        print(
            colored(
                "Not enough data for comparison. Either user-specified developers or developers in the database have no commits after the program end date. Update database",
                "red",
            )
        )

    stat, p_value = mannwhitneyu(user_commits, other_commits)
    comparison_result = (
        f"Mann-Whitney U test statistic: {stat:.3f}, P-value: {p_value:.3f}\n"
    )

    if p_value < 0.25:
        if stat > 0:
            comparison_result += "The user-specified developers have a significantly higher number of commits compared to other developers since the program end date."
        else:
            comparison_result += "The user-specified developers have a significantly lower number of commits compared to other developers since the program end date."
    else:
        comparison_result += "There is no significant difference in the number of commits between user-specified developers and other developers since the program end date."

    return comparison_result


def compare_growth_rate(user_specified_active, other_developers_active, df):
    user_growth_rates = []
    other_growth_rates = []

    for developer in user_specified_active["developer"].unique():
        user_df = df[df["developer"] == developer]
        user_df = user_df.sort_values("month_year")
        user_commits = user_df["total_commits"].tolist()
        user_growth_rate = calculate_average_growth_rate(user_commits)
        user_growth_rates.append(user_growth_rate)

    for developer in other_developers_active["developer"].unique():
        other_df = df[df["developer"] == developer]
        other_df = other_df.sort_values("month_year")
        other_commits = other_df["total_commits"].tolist()
        other_growth_rate = calculate_average_growth_rate(other_commits)
        other_growth_rates.append(other_growth_rate)

    stat, p_value = mannwhitneyu(user_growth_rates, other_growth_rates)
    comparison_result = (
        f"Mann-Whitney U test statistic: {stat:.3f}, P-value: {p_value:.3f}\n"
    )

    if p_value < 0.25:
        if stat > 0:
            comparison_result += "The user-specified developers have a significantly higher average growth rate of commit activity compared to other developers."
        else:
            comparison_result += "The user-specified developers have a significantly lower average growth rate of commit activity compared to other developers."
    else:
        comparison_result += "There is no significant difference in the average growth rate of commit activity between user-specified developers and other developers."

    return comparison_result


def calculate_average_growth_rate(commits):
    growth_rates = []
    for i in range(1, len(commits)):
        if commits[i - 1] != 0:
            growth_rate = (commits[i] - commits[i - 1]) / commits[i - 1]
            growth_rates.append(growth_rate)
    if len(growth_rates) > 0:
        return sum(growth_rates) / len(growth_rates)
    else:
        return 0


def generate_tldr_summary(
    github_handles,
    classification_df,
    analysis_result,
    new_developers_count,
    comparison_result,
    growth_rate_result,
    event_name,
):
    summary = f"### 📝 TLDR Summary for {', '.join(github_handles)}\n\n"

    highly_involved_devs = classification_df[
        classification_df["Classification"] == "Highly involved"
    ]["Developer"].tolist()
    if highly_involved_devs:
        summary += f"**🌟 High Performers:** {', '.join(highly_involved_devs)}\n\n"

    if "higher after the program" in analysis_result:
        summary += "**📈 Commit Activity:** Significantly higher after the program.\n\n"
    elif "lower after the program" in analysis_result:
        summary += "**📉 Commit Activity:** Significantly lower after the program.\n\n"
    else:
        summary += "**🔄 Commit Activity:** No significant change after the program.\n\n"

    if new_developers_count.startswith("Number of new developers"):
        summary += (
            f"**🆕 New Developers:** {new_developers_count.split(':')[1].strip()}\n\n"
        )

    if "significantly higher number of commits" in comparison_result:
        summary += "**🔍 Comparison with Other Developers:** User-specified developers have a significantly higher number of commits.\n\n"
    elif "significantly lower number of commits" in comparison_result:
        summary += "**🔍 Comparison with Other Developers:** User-specified developers have a significantly lower number of commits.\n\n"
    else:
        summary += "**🔍 Comparison with Other Developers:** No significant difference in the number of commits.\n\n"

    if "significantly higher average growth rate" in growth_rate_result:
        summary += "**📈 Growth Rate:** User-specified developers have a significantly higher average growth rate.\n\n"
    elif "significantly lower average growth rate" in growth_rate_result:
        summary += "**📉 Growth Rate:** User-specified developers have a significantly lower average growth rate.\n\n"
    else:
        summary += "**🔄 Growth Rate:** No significant difference in the average growth rate.\n\n"

    if event_name:
        summary += f"*Note: The analysis is based on the {event_name} event.*\n\n"

    return summary


with gr.Blocks() as app:
    gr.Markdown("# 🚀 GitHub Starknet Developer Insights")
    gr.Markdown(
        """
        This tool allows you to analyze the GitHub activity of developers within the Starknet ecosystem.
        Enter GitHub handles separated by commas or upload a CSV file with GitHub handles in a single column
        to see their monthly commit activity, involvement classification, and comparisons with other developers.
        """
    )
    gr.Markdown(
        """
        📺 **Video Tutorial:** Please watch this [5-minute video tutorial](https://www.loom.com/share/b60e7f1bd1ee473b97e9c84c74df692a) examining an African Bootcamp and the Basecamp bootcamp as examples to start using the app effectively.
        """
    )
    with gr.Row():
        with gr.Column():
            text_input = gr.Textbox(
                label="Enter GitHub handles separated by commas",
                placeholder="e.g., user1,user2,user3",
            )
            file_input = gr.File(
                label="Or upload a CSV file with GitHub handles in a single column",
                type="binary",
            )
            gr.Markdown(
                """
                *Note:* When uploading a CSV, ensure it contains a single column of GitHub handles without a header row.
                """
            )
            with gr.Row():
                program_end_date_input = gr.Textbox(
                    label="Program End Date (YYYY-MM-DD)",
                    placeholder="e.g., 2023-06-30",
                )
                event_name_input = gr.Textbox(
                    label="Event Name (optional)",
                    placeholder="e.g., Basecamp, Hackathon",
                )
            gr.Markdown(
                """
                💡 *Tip: Specifying a program end date allows you to analyze the impact of events like Basecamp or Hackathons on developer activity. Leave it blank to analyze overall activity.*
                """
            )
            btn = gr.Button("Analyze")

        with gr.Column():
            tldr_output = gr.Markdown(label="📝 TLDR Summary")

    with gr.Row():
        with gr.Column():
            plot_output = gr.Plot(label="📈 Commits per Month")
        with gr.Column():
            box_plot_output = gr.Plot(label="📊 Box Plot Comparison (Last 3 Months)")

    with gr.Accordion("📊 Statistical Analysis", open=False):
        stat_analysis_output = gr.Textbox(label="Statistical Analysis Results")
        gr.Markdown(
            """
            The Mann-Whitney U test is used to compare the commit activity of developers before and after the program.
            - The test statistic measures the difference in the distribution of commits between the two groups (before and after).
            - The p-value indicates the probability of observing such a difference by chance, assuming there is no real difference between the groups.
            - A p-value less than 0.2 suggests that the difference is considered significant.
            - A positive test statistic indicates that the commit activity is higher after the program, while a negative value indicates lower activity.
            """
        )

    with gr.Accordion("🆕 New Developers", open=False):
        new_developers_output = gr.Textbox(label="Number of New Developers")

    with gr.Accordion("🏆 Developer Classification", open=False):
        table_output = gr.Dataframe(label="Developer Classification")
        gr.Markdown(
            """
            ### Developer Classification Criteria
            - **Always been inactive**: No commits have been recorded in the dataset.
            - **Previously active but no longer**: Had commits earlier but none in the last 3 months.
            - **Low-level active**: Fewer than 20 commits in the last 3 months.
            - **Highly involved**: 20 or more commits in the last 3 months.
            """
        )

    with gr.Accordion("🔍 Comparison with Other Developers", open=False):
        comparison_output = gr.Textbox(label="Comparison with Other Developers")
        gr.Markdown(
            """
            The Mann-Whitney U test is used to compare the commit activity of the user-specified developers with the rest of the developers in the database since the program end date.
            - The test statistic measures the difference in the distribution of commits between the two groups.
            - The p-value indicates the probability of observing such a difference by chance, assuming there is no real difference between the groups.
            - A p-value less than 0.25 suggests that the difference is considered significant.
            - If the test statistic is positive, it means the user-specified developers have a higher number of commits compared to other developers, and vice versa.
            """
        )

    with gr.Accordion("📈 Growth Rate Comparison", open=False):
        growth_rate_output = gr.Textbox(label="Growth Rate Comparison")
        gr.Markdown(
            """
            The average growth rate of commit activity is compared between the user-specified developers and other developers.
            - The growth rate is calculated as the relative change in the number of commits from one month to the next.
            - The Mann-Whitney U test is used to compare the average growth rates between the two groups.
            - A p-value less than 0.25 suggests that the difference in average growth rates is statistically significant.
            - If the test statistic is positive, it means the user-specified developers have a higher average growth rate compared to other developers, and vice versa.
            """
        )

    gr.Markdown(
        """
        💡 *Disclaimer: This information is only for open-source repos and should be taken with a grain of salt. Commits in certain repos may be more important than others, and there are many private repos from several teams that are not included in this analysis.*
        """
    )

    btn.click(
        process_input,
        inputs=[text_input, file_input, program_end_date_input, event_name_input],
        outputs=[
            plot_output,
            box_plot_output,
            table_output,
            stat_analysis_output,
            new_developers_output,
            comparison_output,
            growth_rate_output,
            tldr_output,
        ],
    )

print(colored("Gradio app initialized.", "blue"))

if __name__ == "__main__":
    print(colored("Launching app...", "blue"))
    app.launch(share=True)