Create app.py

app.py

@@ -0,0 +1,362 @@
+import time
+from datetime import datetime
+from functools import lru_cache
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+import gradio as gr
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+from huggingface_hub import HfApi
+
+
+api = HfApi()
+
+
+# -----------------------------
+# Cached HF API helpers
+# -----------------------------
+@lru_cache(maxsize=1000)
+def cached_repo_info(repo_id, repo_type):
+    return api.repo_info(repo_id=repo_id, repo_type=repo_type)
+
+
+@lru_cache(maxsize=1000)
+def cached_list_commits(repo_id, repo_type):
+    return list(api.list_repo_commits(repo_id=repo_id, repo_type=repo_type))
+
+
+@lru_cache(maxsize=100)
+def cached_list_items(username, kind):
+    if kind == "model":
+        return list(api.list_models(author=username))
+    elif kind == "dataset":
+        return list(api.list_datasets(author=username))
+    elif kind == "space":
+        return list(api.list_spaces(author=username))
+    return []
+
+
+# -----------------------------
+# Simple rate limiter
+# -----------------------------
+class RateLimiter:
+    def __init__(self, calls_per_second=10):
+        self.calls_per_second = calls_per_second
+        self.last_call = 0
+
+    def wait(self):
+        current_time = time.time()
+        time_since_last_call = current_time - self.last_call
+        min_interval = 1.0 / self.calls_per_second
+        if time_since_last_call < min_interval:
+            time.sleep(min_interval - time_since_last_call)
+        self.last_call = time.time()
+
+
+rate_limiter = RateLimiter()
+
+
+# -----------------------------
+# Data fetching
+# -----------------------------
+def fetch_commits_for_repo(repo_id, repo_type, selected_year):
+    try:
+        rate_limiter.wait()
+
+        repo_info = cached_repo_info(repo_id, repo_type)
+
+        # Ignore private / gated repos
+        if getattr(repo_info, "private", False) or getattr(repo_info, "gated", False):
+            return [], 0
+
+        commit_dates = []
+        commit_count = 0
+
+        # Initial creation date
+        if getattr(repo_info, "created_at", None) is not None:
+            initial_commit_date = pd.to_datetime(repo_info.created_at).tz_localize(None).date()
+            if initial_commit_date.year == selected_year:
+                commit_dates.append(initial_commit_date)
+                commit_count += 1
+
+        # Repo commits
+        commits = cached_list_commits(repo_id, repo_type)
+        for commit in commits:
+            if getattr(commit, "created_at", None) is None:
+                continue
+            commit_date = pd.to_datetime(commit.created_at).tz_localize(None).date()
+            if commit_date.year == selected_year:
+                commit_dates.append(commit_date)
+                commit_count += 1
+
+        return commit_dates, commit_count
+
+    except Exception:
+        return [], 0
+
+
+def collect_kind_data(username, kind, selected_year):
+    try:
+        items = cached_list_items(username, kind)
+        repo_ids = [item.id for item in items]
+
+        chunk_size = 5
+        total_commits = 0
+        all_commit_dates = []
+
+        for i in range(0, len(repo_ids), chunk_size):
+            chunk = repo_ids[i:i + chunk_size]
+
+            with ThreadPoolExecutor(max_workers=min(5, len(chunk))) as executor:
+                future_to_repo = {
+                    executor.submit(fetch_commits_for_repo, repo_id, kind, selected_year): repo_id
+                    for repo_id in chunk
+                }
+
+                for future in as_completed(future_to_repo):
+                    repo_commits, repo_count = future.result()
+                    if repo_commits:
+                        all_commit_dates.extend(repo_commits)
+                        total_commits += repo_count
+
+        return {
+            "total_items": len(items),
+            "commit_dates": all_commit_dates,
+            "commit_count": total_commits,
+            "error": None,
+        }
+
+    except Exception as e:
+        return {
+            "total_items": 0,
+            "commit_dates": [],
+            "commit_count": 0,
+            "error": f"Error fetching {kind}s for {username}: {str(e)}",
+        }
+
+
+# -----------------------------
+# Plot helpers
+# -----------------------------
+def make_calendar_heatmap(df, title, year):
+    fig, ax = plt.subplots(figsize=(12, 1.3))
+
+    if df.empty:
+        ax.text(0.5, 0.5, f"No {title.lower()} found for {year}.",
+                ha="center", va="center", fontsize=11)
+        ax.axis("off")
+        fig.tight_layout()
+        return fig
+
+    df = df.copy()
+    df["count"] = 1
+    df = df.groupby("date", as_index=False).sum()
+    df["date"] = pd.to_datetime(df["date"])
+
+    start = pd.Timestamp(f"{year}-01-01")
+    end = pd.Timestamp(f"{year}-12-31")
+    all_days = pd.date_range(start=start, end=end)
+
+    heatmap_data = pd.DataFrame({"date": all_days, "count": 0})
+    heatmap_data = heatmap_data.merge(df, on="date", how="left", suffixes=("", "_y"))
+    heatmap_data["count"] = heatmap_data["count_y"].fillna(0)
+    heatmap_data = heatmap_data.drop("count_y", axis=1)
+
+    heatmap_data["dow"] = heatmap_data["date"].dt.dayofweek
+    heatmap_data["week"] = (heatmap_data["date"] - start).dt.days // 7
+
+    pivot = heatmap_data.pivot(index="dow", columns="week", values="count").fillna(0)
+
+    month_starts = pd.date_range(start, end, freq="MS")
+    month_labels = month_starts.strftime("%b")
+    month_positions = month_starts.map(lambda x: (x - start).days // 7)
+
+    from matplotlib.colors import ListedColormap, BoundaryNorm
+    colors = ['#ebedf0', '#9be9a8', '#40c463', '#30a14e', '#216e39']
+    bounds = [0, 1, 3, 11, 31, float('inf')]
+    cmap = ListedColormap(colors)
+    norm = BoundaryNorm(bounds, cmap.N)
+
+    sns.heatmap(
+        pivot.astype(int),
+        ax=ax,
+        cmap=cmap,
+        norm=norm,
+        linewidths=0.5,
+        linecolor="white",
+        square=True,
+        cbar=False,
+        yticklabels=["M", "T", "W", "T", "F", "S", "S"],
+    )
+
+    ax.set_title(title, fontsize=12, pad=10)
+    ax.set_xlabel("")
+    ax.set_ylabel("")
+    ax.set_xticks(month_positions)
+    ax.set_xticklabels(month_labels, fontsize=8)
+    ax.set_yticklabels(ax.get_yticklabels(), rotation=0, fontsize=8)
+
+    fig.tight_layout()
+    return fig
+
+
+def metric_md(label, value):
+    return f"### {label}\n# {value}"
+
+
+# -----------------------------
+# Main callback
+# -----------------------------
+def run_app(selected_username, custom_username, selected_year):
+    username = (custom_username or "").strip() or selected_username
+
+    if not username:
+        empty_fig = make_calendar_heatmap(pd.DataFrame(), "All Commits", selected_year)
+        return (
+            "## Please provide a username or org name.",
+            metric_md("Total Commits", 0),
+            empty_fig,
+            metric_md("🧠 Models", 0),
+            metric_md(f"Commits in {selected_year}", 0),
+            make_calendar_heatmap(pd.DataFrame(), "Models Commits", selected_year),
+            metric_md("📦 Datasets", 0),
+            metric_md(f"Commits in {selected_year}", 0),
+            make_calendar_heatmap(pd.DataFrame(), "Datasets Commits", selected_year),
+            metric_md("🚀 Spaces", 0),
+            metric_md(f"Commits in {selected_year}", 0),
+            make_calendar_heatmap(pd.DataFrame(), "Spaces Commits", selected_year),
+            "No username provided."
+        )
+
+    commits_by_type = {}
+    commit_counts_by_type = {}
+    totals_by_type = {}
+    warnings = []
+
+    for kind in ["model", "dataset", "space"]:
+        result = collect_kind_data(username, kind, int(selected_year))
+        commits_by_type[kind] = result["commit_dates"]
+        commit_counts_by_type[kind] = result["commit_count"]
+        totals_by_type[kind] = result["total_items"]
+        if result["error"]:
+            warnings.append(result["error"])
+
+    total_commits = sum(commit_counts_by_type.values())
+
+    all_commits = []
+    for commits in commits_by_type.values():
+        all_commits.extend(commits)
+
+    all_df = pd.DataFrame(all_commits, columns=["date"])
+    if not all_df.empty:
+        all_df = all_df.drop_duplicates()
+
+    model_df = pd.DataFrame(commits_by_type["model"], columns=["date"])
+    if not model_df.empty:
+        model_df = model_df.drop_duplicates()
+
+    dataset_df = pd.DataFrame(commits_by_type["dataset"], columns=["date"])
+    if not dataset_df.empty:
+        dataset_df = dataset_df.drop_duplicates()
+
+    space_df = pd.DataFrame(commits_by_type["space"], columns=["date"])
+    if not space_df.empty:
+        space_df = space_df.drop_duplicates()
+
+    header = f"## {username}'s Activity in {selected_year}"
+    warnings_text = "\n".join(warnings) if warnings else "Done."
+
+    return (
+        header,
+        metric_md("Total Commits", total_commits),
+        make_calendar_heatmap(all_df, "All Commits", int(selected_year)),
+
+        metric_md("🧠 Models", totals_by_type["model"]),
+        metric_md(f"Commits in {selected_year}", commit_counts_by_type["model"]),
+        make_calendar_heatmap(model_df, "Models Commits", int(selected_year)),
+
+        metric_md("📦 Datasets", totals_by_type["dataset"]),
+        metric_md(f"Commits in {selected_year}", commit_counts_by_type["dataset"]),
+        make_calendar_heatmap(dataset_df, "Datasets Commits", int(selected_year)),
+
+        metric_md("🚀 Spaces", totals_by_type["space"]),
+        metric_md(f"Commits in {selected_year}", commit_counts_by_type["space"]),
+        make_calendar_heatmap(space_df, "Spaces Commits", int(selected_year)),
+
+        warnings_text,
+    )
+
+
+# -----------------------------
+# Gradio UI
+# -----------------------------
+year_options = list(range(datetime.now().year, 2017, -1))
+default_users = ["ritvik77", "facebook", "google", "stabilityai", "Salesforce", "tiiuae", "bigscience"]
+
+with gr.Blocks(title="HF Contributions") as demo:
+    gr.Markdown("# 🤗 Hugging Face Contributions")
+
+    with gr.Sidebar():
+        gr.Markdown("## 👤 Contributor")
+        selected_username = gr.Dropdown(
+            choices=default_users,
+            value="ritvik77",
+            label="Select a username/org"
+        )
+        gr.Markdown("**OR**")
+        custom_username = gr.Textbox(
+            label="Custom username/org",
+            placeholder="Enter custom username/org"
+        )
+        selected_year = gr.Dropdown(
+            choices=year_options,
+            value=year_options[0],
+            label="🗓️ Year"
+        )
+        run_button = gr.Button("Fetch commit data", variant="primary")
+
+    status_header = gr.Markdown("## Ready")
+    total_commits_md = gr.Markdown("### Total Commits\n# 0")
+    all_plot = gr.Plot(label="All Commits")
+
+    with gr.Row():
+        with gr.Column():
+            models_total_md = gr.Markdown("### 🧠 Models\n# 0")
+            models_commits_md = gr.Markdown(f"### Commits in {year_options[0]}\n# 0")
+            models_plot = gr.Plot(label="Models Commits")
+
+        with gr.Column():
+            datasets_total_md = gr.Markdown("### 📦 Datasets\n# 0")
+            datasets_commits_md = gr.Markdown(f"### Commits in {year_options[0]}\n# 0")
+            datasets_plot = gr.Plot(label="Datasets Commits")
+
+        with gr.Column():
+            spaces_total_md = gr.Markdown("### 🚀 Spaces\n# 0")
+            spaces_commits_md = gr.Markdown(f"### Commits in {year_options[0]}\n# 0")
+            spaces_plot = gr.Plot(label="Spaces Commits")
+
+    logs_box = gr.Textbox(label="Logs / Warnings", interactive=False, lines=6)
+
+    run_button.click(
+        fn=run_app,
+        inputs=[selected_username, custom_username, selected_year],
+        outputs=[
+            status_header,
+            total_commits_md,
+            all_plot,
+            models_total_md,
+            models_commits_md,
+            models_plot,
+            datasets_total_md,
+            datasets_commits_md,
+            datasets_plot,
+            spaces_total_md,
+            spaces_commits_md,
+            spaces_plot,
+            logs_box,
+        ],
+    )
+
+demo.queue().launch()