use bittensor python api

app.py

@@ -9,48 +9,45 @@ g_cached_data: pd.DataFrame | None = None
 g_last_fetch_time = 0.0
 
 
-def get_incentive_percent_for_key(key, sn, incentive, substrate) -> tuple[float, int]:
-    uid = substrate.query('SubtensorModule', 'Uids', [sn, key])
-    if uid and uid.value is not None:
-        owner_incentive = int(incentive[uid.value])
-        if owner_incentive > 0:
-            return (owner_incentive / 65535) * 100, uid.value
-    return -1, -1
-
-
 def fetch_incentive_data() -> pd.DataFrame:
-    print("Starting data fetch...")
     data = []
     subtensor = bt.subtensor(network="finney")
-    substrate = subtensor.substrate
-        
-    for sn in range(128):
-        incentive = substrate.query("SubtensorModule", "Incentive", [sn])
-        owner_ck = substrate.query('SubtensorModule', 'SubnetOwner', [sn])
-        assert incentive, "WTF"
-        assert owner_ck, "WTF"
-        sn_link = f"[{sn}](https://taostats.io/subnets/{sn})"
+    print("connected to subtensor")
+    subnets = subtensor.all_subnets()
+    print("fetched all subnets")
+    metagraphs = subtensor.get_all_metagraphs_info()
+    print("fetched all metagraphs")
+
+    assert subnets, "WTF"
+    assert metagraphs, "WTF"
+
+    for sn in range(1, 129):
+        subnet = subnets[sn]
+        metagraph = metagraphs[sn]
+        address_to_uid = {hk: i for i, hk in enumerate(metagraph.hotkeys)}
+        addresses = [("coldkey", subnet.owner_coldkey), ("hotkey", subnet.owner_hotkey)]
 
-        ck_incentive, ck_uid = get_incentive_percent_for_key(owner_ck, sn, incentive, substrate)
-        if ck_incentive > 0:
-            print(f"Found incentive for SN {sn} owner coldkey.")
-            address_link = f"[{owner_ck}](https://taostats.io/coldkey/{owner_ck})"
-            data.append([sn_link, f"{ck_incentive:.2f}%", ck_uid, "Coldkey", address_link])
-            continue
+        for key_type, address in addresses:
+            uid = address_to_uid.get(address, None)
+            if uid is None:
+                continue
 
-        owner_hks = substrate.query("SubtensorModule", "OwnedHotkeys", [owner_ck])
-        if owner_hks and owner_hks.value:
-            for byte_array in owner_hks.value:
-                owner_hk = Keypair(public_key=bytes(byte_array[0]), ss58_format=42).ss58_address
-                hk_incentive, hk_uid = get_incentive_percent_for_key(owner_hk, sn, incentive, substrate)
-                if hk_incentive > 0:
-                    print(f"Found incentive for SN {sn} owner hotkey.")
-                    address_link = f"[{owner_hk}](https://taostats.io/hotkey/{owner_hk})"
-                    data.append([sn_link, f"{hk_incentive:.2f}%", hk_uid, "Hotkey", address_link])
-                    break
+            incentive = metagraph.incentives[uid]
+            if incentive <= 0:
+                continue
+
+            data.append([
+                f"[{sn}](https://taostats.io/subnets/{sn})",
+                f"{incentive*100:.2f}%",
+                uid,
+                key_type,
+                f"[{address}](https://taostats.io/{key_type}/{address})"
+            ])
+            break
 
     data = [(i+1, *d) for i, d in enumerate(data)] 
     df = pd.DataFrame(data, columns=["#", "Subnet", "Burn", "UID", "Key", "Address"]) # type: ignore
+    print(f"{len(data)} subnets burn")
     return df
 
 
@@ -59,7 +56,9 @@ def get_cached_data() -> pd.DataFrame:
     if g_cached_data is None or (time.time() - g_last_fetch_time) > 1200: # 20 min
         g_last_fetch_time = time.time()
         g_cached_data = fetch_incentive_data()
-    return g_cached_data
+
+    time_str = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(g_last_fetch_time + 1200))
+    return time_str, g_cached_data
 
 
 with gr.Blocks(title="Bittensor Subnet Incentives") as demo:
@@ -69,13 +68,12 @@ with gr.Blocks(title="Bittensor Subnet Incentives") as demo:
         This dashboard displays the burn percentage set by subnet owners for miners.
         """
     )
-
+    next_process_text = gr.Textbox(label="Next refresh time", interactive=False)
     output_df = gr.DataFrame(
         datatype=["number", "markdown", "str", "number", "str", "markdown"],
         label="Subnet Burn Data",
         interactive=False,
-        row_count=(60, "dynamic"),
-        col_count=(6, "fixed")
+        max_height=1000000
     )
-    demo.load(get_cached_data, None, output_df)
+    demo.load(get_cached_data, None, [next_process_text, output_df])
     demo.launch()