temp migration

app.py

@@ -59,8 +59,8 @@ con.execute("SET enable_object_cache = false;")
 
 # Load parquet files from Hugging Face using DuckDB
 HF_DATASET_ID = "mmpr/open_model_evolution_data"
-hf_parquet_url_1 = "https://huggingface.co/datasets/mmpr/open_model_evolution_data/resolve/main/all_downloads_with_annotations.parquet"
-hf_parquet_url_2 = "https://huggingface.co/datasets/mmpr/open_model_evolution_data/resolve/main/one_year_rolling.parquet"
+hf_parquet_url_1 = "https://huggingface.co/datasets/emsesc/open_model_evolution_data/resolve/main/all_downloads_with_annotations-1.parquet"
+hf_parquet_url_2 = "https://huggingface.co/datasets/emsesc/open_model_evolution_data/resolve/main/one_year_rolling-2.parquet"
 
 print(f"Attempting to connect to dataset from Hugging Face Hub: {HF_DATASET_ID}")
 try:
@@ -745,17 +745,26 @@ def _get_filtered_top_n_from_duckdb(
     slider_value, group_col, top_n, view="all_downloads"
 ):
     """
-    Query DuckDB directly to get top N entries with metadata
-    This minimizes data transfer by doing aggregation in DuckDB
+    Query DuckDB to get model-level rows with per-model total_downloads (delta or full)
+    Returns a DataFrame with columns including:
+      - group_key (the grouping column)
+      - org_country_single, author, derived_author, merged_country_groups_single, merged_modality, model
+      - total_downloads (per-model downloads in requested window)
+      - percent_of_total (percent of total across all returned model deltas)
     """
-    # Build time filter clause
-    time_clause = ""
+
+    # Compute date window (if slider_value provided, use it; otherwise cover full range)
     if slider_value and len(slider_value) == 2:
         start = pd.to_datetime(slider_value[0], unit="s")
         end = pd.to_datetime(slider_value[1], unit="s")
-        time_clause = f"WHERE time >= '{start}' AND time <= '{end}'"
+    else:
+        start = pd.to_datetime("1970-01-01")
+        end = end_dt  # defined near top of file when parquet was loaded
+
+    start_str = str(start)
+    end_str = str(end)
 
-    # If grouping by country, group by the transformed country column
+    # If grouping by country, transform some country values
     if group_col == "org_country_single":
         group_expr = """CASE 
             WHEN org_country_single IN ('HF', 'United States of America') THEN 'United States of America'
@@ -765,12 +774,11 @@ def _get_filtered_top_n_from_duckdb(
     else:
         group_expr = group_col
 
-    # Build a lookup for author -> country mapping
-    # When grouping by derived_author, we need to find the country where derived_author = author
+    # Derived-author requires author->country lookup; build separate SQL for that case
     if group_col == "derived_author":
         query = f"""
         WITH base_data AS (
-            SELECT 
+            SELECT
                 {group_expr} AS group_key,
                 CASE 
                     WHEN org_country_single IN ('HF', 'United States of America') THEN 'United States of America'
@@ -781,93 +789,112 @@ def _get_filtered_top_n_from_duckdb(
                 derived_author,
                 merged_country_groups_single,
                 merged_modality,
-                downloads,
-                model
+                model,
+                time,
+                downloadsAllTime
             FROM {view}
-            {time_clause}
         ),
-        
-        -- Create a lookup table for derived_author -> country
+
         author_country_lookup AS (
             SELECT DISTINCT
                 author,
-                FIRST_VALUE(org_country_single) OVER (PARTITION BY author ORDER BY downloads DESC) AS author_country
+                FIRST_VALUE(org_country_single) OVER (PARTITION BY author ORDER BY downloadsAllTime DESC) AS author_country
             FROM base_data
             WHERE author IS NOT NULL
         ),
 
-        total_downloads_cte AS (
-            SELECT SUM(downloads) AS total_downloads_all
+        model_metrics AS (
+            SELECT
+                model,
+                group_key,
+                ANY_VALUE(org_country_single) AS org_country_single,
+                ANY_VALUE(author) AS author,
+                ANY_VALUE(derived_author) AS derived_author,
+                ANY_VALUE(merged_country_groups_single) AS merged_country_groups_single,
+                ANY_VALUE(merged_modality) AS merged_modality,
+                COALESCE(MAX(CASE WHEN time <= '{end_str}' THEN downloadsAllTime END), 0)
+                - COALESCE(MAX(CASE WHEN time < '{start_str}' THEN downloadsAllTime END), 0)
+                AS total_downloads
             FROM base_data
+            GROUP BY model, group_key
         ),
 
-        top_items AS (
-            SELECT 
-                b.group_key AS name,
-                SUM(b.downloads) AS total_downloads,
-                ROUND(SUM(b.downloads) * 100.0 / t.total_downloads_all, 2) AS percent_of_total,
-                COALESCE(acl.author_country, ANY_VALUE(b.org_country_single)) AS org_country_single,
-                ANY_VALUE(b.author) AS author,
-                ANY_VALUE(b.derived_author) AS derived_author,
-                ANY_VALUE(b.merged_country_groups_single) AS merged_country_groups_single,
-                ANY_VALUE(b.merged_modality) AS merged_modality,
-                ANY_VALUE(b.model) AS model
-            FROM base_data b
-            CROSS JOIN total_downloads_cte t
-            LEFT JOIN author_country_lookup acl ON b.group_key = acl.author
-            GROUP BY b.group_key, acl.author_country, t.total_downloads_all
+        total_downloads_cte AS (
+            SELECT SUM(total_downloads) AS total_downloads_all FROM model_metrics
         )
 
-        SELECT *
-        FROM top_items
-        ORDER BY total_downloads DESC
-        LIMIT {top_n};
+        SELECT
+            mm.model,
+            mm.group_key,
+            COALESCE(acl.author_country, mm.org_country_single) AS org_country_single,
+            mm.author,
+            mm.derived_author,
+            mm.merged_country_groups_single,
+            mm.merged_modality,
+            mm.total_downloads,
+            CASE WHEN td.total_downloads_all = 0 THEN 0 ELSE ROUND(mm.total_downloads * 100.0 / td.total_downloads_all, 2) END AS percent_of_total
+        FROM model_metrics mm
+        LEFT JOIN author_country_lookup acl ON mm.group_key = acl.author
+        CROSS JOIN total_downloads_cte td
+        WHERE mm.total_downloads > 0
+        ORDER BY mm.total_downloads DESC
+        LIMIT {top_n * 10};
         """
     else:
         query = f"""
         WITH base_data AS (
-            SELECT 
+            SELECT
                 {group_expr} AS group_key,
                 CASE 
                     WHEN org_country_single IN ('HF', 'United States of America') THEN 'United States of America'
-                    WHEN org_country_single IN ('International', 'Online') THEN 'International/Online'
+                    WHEN org_country_single IN ('International', 'Online', 'Online?') THEN 'International/Online'
                     ELSE org_country_single
                 END AS org_country_single,
                 author,
                 derived_author,
                 merged_country_groups_single,
                 merged_modality,
-                downloads,
-                model
+                model,
+                time,
+                downloadsAllTime
             FROM {view}
-            {time_clause}
         ),
 
-        total_downloads_cte AS (
-            SELECT SUM(downloads) AS total_downloads_all
+        model_metrics AS (
+            SELECT
+                model,
+                group_key,
+                ANY_VALUE(org_country_single) AS org_country_single,
+                ANY_VALUE(author) AS author,
+                ANY_VALUE(derived_author) AS derived_author,
+                ANY_VALUE(merged_country_groups_single) AS merged_country_groups_single,
+                ANY_VALUE(merged_modality) AS merged_modality,
+                COALESCE(MAX(CASE WHEN time <= '{end_str}' THEN downloadsAllTime END), 0)
+                - COALESCE(MAX(CASE WHEN time < '{start_str}' THEN downloadsAllTime END), 0)
+                AS total_downloads
             FROM base_data
+            GROUP BY model, group_key
         ),
 
-        top_items AS (
-            SELECT 
-                b.group_key AS name,
-                SUM(b.downloads) AS total_downloads,
-                ROUND(SUM(b.downloads) * 100.0 / t.total_downloads_all, 2) AS percent_of_total,
-                ANY_VALUE(b.org_country_single) AS org_country_single,
-                ANY_VALUE(b.author) AS author,
-                ANY_VALUE(b.derived_author) AS derived_author,
-                ANY_VALUE(b.merged_country_groups_single) AS merged_country_groups_single,
-                ANY_VALUE(b.merged_modality) AS merged_modality,
-                ANY_VALUE(b.model) AS model
-            FROM base_data b
-            CROSS JOIN total_downloads_cte t
-            GROUP BY b.group_key, t.total_downloads_all
+        total_downloads_cte AS (
+            SELECT SUM(total_downloads) AS total_downloads_all FROM model_metrics
         )
 
-        SELECT *
-        FROM top_items
-        ORDER BY total_downloads DESC
-        LIMIT {top_n};
+        SELECT
+            mm.model,
+            mm.group_key,
+            mm.org_country_single,
+            mm.author,
+            mm.derived_author,
+            mm.merged_country_groups_single,
+            mm.merged_modality,
+            mm.total_downloads,
+            CASE WHEN td.total_downloads_all = 0 THEN 0 ELSE ROUND(mm.total_downloads * 100.0 / td.total_downloads_all, 2) END AS percent_of_total
+        FROM model_metrics mm
+        CROSS JOIN total_downloads_cte td
+        WHERE mm.total_downloads > 0
+        ORDER BY mm.total_downloads DESC
+        LIMIT {top_n * 10};
         """
 
     return con.execute(query).fetchdf()

graphs/leaderboard.py

@@ -317,39 +317,59 @@ def get_top_n_leaderboard(filtered_df, group_col, top_n=10, derived_author_toggl
     Get top N entries for a leaderboard
 
     Args:
-        filtered_df: Pandas DataFrame (already filtered by time from DuckDB query)
+        filtered_df: Pandas DataFrame of model-level rows. Must contain:
+            - group_col (the grouping key)
+            - total_downloads (per-model downloads for the requested window)
+            - plus metadata columns: org_country_single, author, derived_author, merged_country_groups_single, merged_modality, model
         group_col: Column to group by
         top_n: Number of top entries to return
         derived_author_toggle: If True, attribute to model uploader (derived_author); if False, attribute to original model creator (author)
 
     Returns:
         tuple: (display_df, download_df)
+            display_df: DataFrame with columns ["Name","Metadata","% of total"] for rendering
+            download_df: DataFrame suitable for CSV download with numeric totals and metadata columns
     """
 
-    # Group by and get top N
-    top = (
-        filtered_df.groupby(group_col)[["total_downloads", "percent_of_total"]]
+    if filtered_df is None or filtered_df.empty:
+        return pd.DataFrame(), pd.DataFrame()
+
+    # Ensure numeric total_downloads
+    if "total_downloads" not in filtered_df.columns:
+        # fallback if older code still returned 'downloads' (unlikely)
+        if "downloads" in filtered_df.columns:
+            filtered_df["total_downloads"] = filtered_df["downloads"]
+        else:
+            filtered_df["total_downloads"] = 0
+
+    # Compute overall total across all models in this filtered set
+    total_all = filtered_df["total_downloads"].sum()
+    if total_all == 0:
+        return pd.DataFrame(), pd.DataFrame()
+
+    # Sum per group (group_col) to get group totals
+    grouped = (
+        filtered_df.groupby(group_col)["total_downloads"]
         .sum()
-        .nlargest(top_n, columns="total_downloads")
         .reset_index()
-        .rename(
-            columns={
-                group_col: "Name",
-                "total_downloads": "Total Value",
-                "percent_of_total": "% of total",
-            }
-        )
+        .rename(columns={group_col: "Name", "total_downloads": "Total Value"})
     )
 
-    # Create a downloadable version of the leaderboard
+    # Pick top N groups by summed downloads
+    top = grouped.nlargest(top_n, columns="Total Value").reset_index(drop=True)
+
+    # Compute percent of total for display (rounded)
+    top["% of total"] = top["Total Value"].apply(lambda v: round(v * 100.0 / total_all, 2))
+
+    # Build download version (numeric)
     download_top = top.copy()
     download_top["Total Value"] = download_top["Total Value"].astype(int)
     download_top["% of total"] = download_top["% of total"].round(2)
 
-    # All relevant metadata columns
+    # All relevant metadata columns for the grouping
     meta_cols = meta_cols_map.get(group_col, [])
 
-    # Collect all metadata per top n for each category (country, author, model)
+    # Collect metadata per group by inspecting the underlying model-level rows
     meta_map = {}
     download_map = {}
 
@@ -359,7 +379,7 @@ def get_top_n_leaderboard(filtered_df, group_col, top_n=10, derived_author_toggl
         download_map[name] = {}
         for col in meta_cols:
             if col in name_data.columns:
-                unique_vals = name_data[col].unique()
+                unique_vals = name_data[col].dropna().unique()
                 meta_map[name][col] = list(unique_vals)
                 download_map[name][col] = list(unique_vals)
 
@@ -381,7 +401,6 @@ def get_top_n_leaderboard(filtered_df, group_col, top_n=10, derived_author_toggl
             except Exception:
                 flag_emoji = country_emoji_fallback.get(c, "🌍")
             chips.append((flag_emoji, c, "country"))
-            # Add downloads chip for country (only once)
 
         # Author - use derived_author_toggle to determine which column
         author_key = "derived_author" if derived_author_toggle else "author"
@@ -399,67 +418,66 @@ def get_top_n_leaderboard(filtered_df, group_col, top_n=10, derived_author_toggl
             if pd.notna(m):
                 chips.append(("", m, "modality"))
 
-        # Total downloads
-        for d in meta.get("total_downloads", []):
-            formatted_downloads = format_large_number(d)
+        # Total downloads (aggregate numeric value for this group)
+        # Use the summed value from top (we can retrieve it)
+        # but we also include any per-model totals if desired - keep simple: use group total
+        group_total = int(top.loc[top["Name"] == nm, "Total Value"].iloc[0]) if nm in top["Name"].values else None
+        if group_total is not None:
+            formatted_downloads = format_large_number(group_total)
             chips.append(("⬇️", formatted_downloads, "downloads"))
 
         return chips
 
-    # Function to create downloadable dataframe metadata
-    def build_download_metadata(nm):
-        meta = download_map.get(nm, {})
-        download_info = {}
+    # Attach Metadata column for display DataFrame
+    display_df = top.rename(columns={"Total Value": "total_downloads"})
+    display_df["Metadata"] = display_df["Name"].astype(object).apply(build_metadata)
 
-        for col in meta_cols:
-            if col not in meta or not meta[col]:
-                continue
+    # Format display_df columns for render_table_content
+    display_df_formatted = display_df.rename(columns={"% of total": "% of total"})
+    # Keep only necessary columns in expected order
+    display_for_render = display_df_formatted[["Name", "Metadata", "% of total"]]
 
-            vals = meta.get(col, [])
-            if vals:
-                download_info[col] = ", ".join(str(v) for v in vals if pd.notna(v))
+    # Build download dataframe with metadata for CSV
+    download_info_list = []
+    for nm in download_top["Name"]:
+        info = {}
+        meta = download_map.get(nm, {})
+        for col in meta_cols:
+            if col in meta and meta[col]:
+                info[col] = ", ".join(str(v) for v in meta[col] if pd.notna(v))
             else:
-                download_info[col] = ""
-
-        return download_info
-
-    # Apply metadata builder to top dataframe
-    top["Metadata"] = top["Name"].astype(object).apply(build_metadata)
+                info[col] = ""
+        # attach totals
+        info["Total Value"] = int(download_top.loc[download_top["Name"] == nm, "Total Value"].iloc[0])
+        info["% of total"] = float(download_top.loc[download_top["Name"] == nm, "% of total"].iloc[0])
+        download_info_list.append(info)
 
-    # Capitalize "user" back to "User" for display
-    top["Name"] = top["Name"].replace("user", "User")
-
-    # Build download dataframe with metadata
-    download_info_list = [build_download_metadata(nm) for nm in download_top["Name"]]
     download_info_df = pd.DataFrame(download_info_list)
-    download_top = pd.concat([download_top, download_info_df], axis=1)
+    download_top = pd.concat([download_top.reset_index(drop=True), download_info_df.reset_index(drop=True)], axis=1)
 
-    return top[["Name", "Metadata", "% of total"]], download_top
+    return display_for_render, download_top
 
 
 def get_top_n_from_duckdb(
     con, group_col, top_n=10, time_filter=None, view="all_downloads"
 ):
     """
-    Query DuckDB directly to get top N entries with minimal data transfer
-
-    Args:
-        con: DuckDB connection object
-        group_col: Column to group by
-        top_n: Number of top entries
-        time_filter: Optional tuple of (start_timestamp, end_timestamp)
-
-    Returns:
-        Pandas DataFrame with only the rows needed for top N
+    Query DuckDB directly to get model-level rows with per-model total_downloads (delta or full)
+    Returns rows similar to _get_filtered_top_n_from_duckdb in app.py.
     """
-    # Build time filter clause
-    time_clause = ""
-    if time_filter:
+    # Compute date window
+    if time_filter and len(time_filter) == 2:
         start = pd.to_datetime(time_filter[0], unit="s")
         end = pd.to_datetime(time_filter[1], unit="s")
-        time_clause = f"WHERE time >= '{start}' AND time <= '{end}'"
+    else:
+        start = pd.to_datetime("1970-01-01")
+        # We cannot access end_dt here; rely on time_filter for end in typical use.
+        end = pd.Timestamp.now()
 
-    # If grouping by country, group by the transformed country column
+    start_str = str(start)
+    end_str = str(end)
+
+    # If grouping by country, transform some country values
     if group_col == "org_country_single":
         group_expr = """CASE 
             WHEN org_country_single IN ('HF', 'United States of America') THEN 'United States of America'
@@ -469,108 +487,127 @@ def get_top_n_from_duckdb(
     else:
         group_expr = group_col
 
-    # When grouping by derived_author, lookup the country where derived_author = author
+    # Derived author special-case
     if group_col == "derived_author":
         query = f"""
         WITH base_data AS (
-            SELECT 
+            SELECT
                 {group_expr} AS group_key,
                 CASE 
                     WHEN org_country_single IN ('HF', 'United States of America') THEN 'United States of America'
-                    WHEN org_country_single IN ('International', 'Online') THEN 'International/Online'
+                    WHEN org_country_single IN ('International', 'Online', 'Online?') THEN 'International/Online'
                     ELSE org_country_single
                 END AS org_country_single,
                 author,
                 derived_author,
                 merged_country_groups_single,
                 merged_modality,
-                downloads,
-                model
+                model,
+                time,
+                downloadsAllTime
             FROM {view}
-            {time_clause}
         ),
-        
-        -- Create a lookup table for derived_author -> country
+
         author_country_lookup AS (
             SELECT DISTINCT
                 author,
-                FIRST_VALUE(org_country_single) OVER (PARTITION BY author ORDER BY downloads DESC) AS author_country
+                FIRST_VALUE(org_country_single) OVER (PARTITION BY author ORDER BY downloadsAllTime DESC) AS author_country
             FROM base_data
             WHERE author IS NOT NULL
         ),
 
-        total_downloads_cte AS (
-            SELECT SUM(downloads) AS total_downloads_all
+        model_metrics AS (
+            SELECT
+                model,
+                group_key,
+                ANY_VALUE(org_country_single) AS org_country_single,
+                ANY_VALUE(author) AS author,
+                ANY_VALUE(derived_author) AS derived_author,
+                ANY_VALUE(merged_country_groups_single) AS merged_country_groups_single,
+                ANY_VALUE(merged_modality) AS merged_modality,
+                COALESCE(MAX(CASE WHEN time <= '{end_str}' THEN downloadsAllTime END), 0)
+                - COALESCE(MAX(CASE WHEN time < '{start_str}' THEN downloadsAllTime END), 0)
+                AS total_downloads
             FROM base_data
+            GROUP BY model, group_key
         ),
 
-        top_items AS (
-            SELECT 
-                b.group_key AS name,
-                SUM(b.downloads) AS total_downloads,
-                ROUND(SUM(b.downloads) * 100.0 / t.total_downloads_all, 2) AS percent_of_total,
-                COALESCE(acl.author_country, ANY_VALUE(b.org_country_single)) AS org_country_single,
-                ANY_VALUE(b.author) AS author,
-                ANY_VALUE(b.derived_author) AS derived_author,
-                ANY_VALUE(b.merged_country_groups_single) AS merged_country_groups_single,
-                ANY_VALUE(b.merged_modality) AS merged_modality,
-                ANY_VALUE(b.model) AS model
-            FROM base_data b
-            CROSS JOIN total_downloads_cte t
-            LEFT JOIN author_country_lookup acl ON b.group_key = acl.author
-            GROUP BY b.group_key, acl.author_country, t.total_downloads_all
+        total_downloads_cte AS (
+            SELECT SUM(total_downloads) AS total_downloads_all FROM model_metrics
         )
 
-        SELECT *
-        FROM top_items
-        ORDER BY total_downloads DESC
-        LIMIT {top_n};
+        SELECT
+            mm.model,
+            mm.group_key,
+            COALESCE(acl.author_country, mm.org_country_single) AS org_country_single,
+            mm.author,
+            mm.derived_author,
+            mm.merged_country_groups_single,
+            mm.merged_modality,
+            mm.total_downloads,
+            CASE WHEN td.total_downloads_all = 0 THEN 0 ELSE ROUND(mm.total_downloads * 100.0 / td.total_downloads_all, 2) END AS percent_of_total
+        FROM model_metrics mm
+        LEFT JOIN author_country_lookup acl ON mm.group_key = acl.author
+        CROSS JOIN total_downloads_cte td
+        WHERE mm.total_downloads > 0
+        ORDER BY mm.total_downloads DESC
+        LIMIT {top_n * 10};
         """
     else:
         query = f"""
         WITH base_data AS (
-            SELECT 
+            SELECT
                 {group_expr} AS group_key,
                 CASE 
                     WHEN org_country_single IN ('HF', 'United States of America') THEN 'United States of America'
-                    WHEN org_country_single IN ('International', 'Online') THEN 'International/Online'
+                    WHEN org_country_single IN ('International', 'Online', 'Online?') THEN 'International/Online'
                     ELSE org_country_single
                 END AS org_country_single,
                 author,
                 derived_author,
                 merged_country_groups_single,
                 merged_modality,
-                downloads,
-                model
+                model,
+                time,
+                downloadsAllTime
             FROM {view}
-            {time_clause}
         ),
 
-        total_downloads_cte AS (
-            SELECT SUM(downloads) AS total_downloads_all
+        model_metrics AS (
+            SELECT
+                model,
+                group_key,
+                ANY_VALUE(org_country_single) AS org_country_single,
+                ANY_VALUE(author) AS author,
+                ANY_VALUE(derived_author) AS derived_author,
+                ANY_VALUE(merged_country_groups_single) AS merged_country_groups_single,
+                ANY_VALUE(merged_modality) AS merged_modality,
+                COALESCE(MAX(CASE WHEN time <= '{end_str}' THEN downloadsAllTime END), 0)
+                - COALESCE(MAX(CASE WHEN time < '{start_str}' THEN downloadsAllTime END), 0)
+                AS total_downloads
             FROM base_data
+            GROUP BY model, group_key
         ),
 
-        top_items AS (
-            SELECT 
-                b.group_key AS name,
-                SUM(b.downloads) AS total_downloads,
-                ROUND(SUM(b.downloads) * 100.0 / t.total_downloads_all, 2) AS percent_of_total,
-                ANY_VALUE(b.org_country_single) AS org_country_single,
-                ANY_VALUE(b.author) AS author,
-                ANY_VALUE(b.derived_author) AS derived_author,
-                ANY_VALUE(b.merged_country_groups_single) AS merged_country_groups_single,
-                ANY_VALUE(b.merged_modality) AS merged_modality,
-                ANY_VALUE(b.model) AS model
-            FROM base_data b
-            CROSS JOIN total_downloads_cte t
-            GROUP BY b.group_key, t.total_downloads_all
+        total_downloads_cte AS (
+            SELECT SUM(total_downloads) AS total_downloads_all FROM model_metrics
         )
 
-        SELECT *
-        FROM top_items
-        ORDER BY total_downloads DESC
-        LIMIT {top_n};
+        SELECT
+            mm.model,
+            mm.group_key,
+            mm.org_country_single,
+            mm.author,
+            mm.derived_author,
+            mm.merged_country_groups_single,
+            mm.merged_modality,
+            mm.total_downloads,
+            CASE WHEN td.total_downloads_all = 0 THEN 0 ELSE ROUND(mm.total_downloads * 100.0 / td.total_downloads_all, 2) END AS percent_of_total
+        FROM model_metrics mm
+        CROSS JOIN total_downloads_cte td
+        WHERE mm.total_downloads > 0
+        ORDER BY mm.total_downloads DESC
+        LIMIT {top_n * 10};
         """
 
     try: