[WIP] Commander (BTTUI) Backend Server

bittensor/__init__.py

@@ -22,9 +22,6 @@
 
 # Install and apply nest asyncio to allow the async functions
 # to run in a .ipynb
-import nest_asyncio
-
-nest_asyncio.apply()
 
 # Bittensor code and protocol version.
 __version__ = "7.0.0"

bittensor/commander/data.py

@@ -0,0 +1,34 @@
+from typing import Optional
+
+from pydantic import BaseModel
+
+import bittensor
+
+
+class Config:
+    netuid = 0
+    wallet = None
+    initialized = False
+    json_encrypted_path = None
+    json_encrypted_pw = None
+
+    def __bool__(self):
+        return self.initialized
+
+    def setup(self, conf: "ConfigBody"):
+        self.initialized = True
+        self.netuid = conf.netuid
+        self.wallet = bittensor.wallet(
+            name=conf.wallet["name"],
+            hotkey=conf.wallet["hotkey"],
+            path=conf.wallet["path"],
+        )  # maybe config
+        self.json_encrypted_path = conf.json_encrypted_path
+        self.json_encrypted_pw = conf.json_encrypted_pw
+
+
+class ConfigBody(BaseModel):
+    netuid: int = 0
+    wallet: dict
+    json_encrypted_path: Optional[str] = None
+    json_encrypted_pw: Optional[str] = None

bittensor/commander/server.py

@@ -0,0 +1,116 @@
+import asyncio
+from functools import partial
+import time
+
+# import sys
+
+from fastapi import FastAPI, Request, Response, HTTPException, Depends
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+
+# import uvicorn
+
+import bittensor
+from bittensor.commands import network
+from bittensor.commands import metagraph
+from bittensor.commands import register
+from bittensor.commands import list as list_commands
+from bittensor.commands import overview
+from bittensor.commands import transfer
+from bittensor.commands import inspect
+from bittensor.commands import wallets
+from bittensor.commander import data
+
+
+# TODO app-wide error-handling
+
+sub = bittensor.subtensor("test")
+app = FastAPI(debug=True)
+config = data.Config()
+
+
+@app.post("/setup")
+async def setup(conf: data.ConfigBody):
+    config.setup(conf)
+    return JSONResponse(status_code=200, content={"success": True})
+
+
+async def check_config():
+    if not config:
+        raise HTTPException(status_code=401, detail="Config missing")
+
+
+async def run_fn(command_class, *params):
+    start = time.time()
+    try:
+        if hasattr(command_class, "commander_run"):
+            # Offload synchronous execution to the threadpool
+            response_content = await command_class.commander_run(sub, config=config)
+            print(command_class, time.time() - start)
+            return JSONResponse(content=response_content)
+        else:
+            raise HTTPException(
+                status_code=501, detail="Command implementation missing"
+            )
+    except Exception as e:
+        raise
+        # raise HTTPException(status_code=500, detail=str(e))
+
+
+# Subnets
+@app.get("/subnets/{sub_cmd}", dependencies=[Depends(check_config)])
+async def get_subnet(sub_cmd: str):
+    routing_list = {
+        "list": network.SubnetListCommand,
+        "metagraph": metagraph.MetagraphCommand,
+        "lock_cost": network.SubnetLockCostCommand,
+        "create": network.RegisterSubnetworkCommand,
+        "pow_register": register.PowRegisterCommand,
+        "register": register.RegisterCommand,
+        "hyperparameters": network.SubnetHyperparamsCommand,
+    }
+    return await run_fn(routing_list[sub_cmd])
+
+
+# Wallet
+@app.get("/wallet/hotkey/{sub_cmd}", dependencies=[Depends(check_config)])
+async def wallet_hotkey(sub_cmd: str):
+    routing_list = {
+        "new": wallets.NewHotkeyCommand,
+        "regen": wallets.RegenHotkeyCommand,
+        "swap": register.SwapHotkeyCommand,
+    }
+    return await run_fn(routing_list[sub_cmd])
+
+
+@app.get("/wallet/coldkey/{sub_cmd}", dependencies=[Depends(check_config)])
+async def wallet_coldkey(sub_cmd: str):
+    routing_list = {
+        "new": wallets.NewColdkeyCommand,
+        "regen": wallets.RegenColdkeyCommand,
+        "regen/pub": wallets.RegenColdkeypubCommand,
+    }
+    return await run_fn(routing_list[sub_cmd])
+
+
+@app.get("/wallet/{sub_cmd}", dependencies=[Depends(check_config)])
+async def wallet(sub_cmd: str):
+    routing_list = {
+        "list": list_commands.ListCommand,
+        "overview": overview.OverviewCommand,
+        "transfer": transfer.TransferCommand,
+        "inspect": inspect.InspectCommand,
+        "balance": wallets.WalletBalanceCommand,
+        "create": wallets.WalletCreateCommand,
+        "faucet": register.RunFaucetCommand,
+        "update": wallets.UpdateWalletCommand,
+        "history": wallets.GetWalletHistoryCommand,
+    }
+    return await run_fn(routing_list[sub_cmd])
+
+
+# Root
+
+# Sudo
+
+# Stake

bittensor/commands/metagraph.py

@@ -16,8 +16,14 @@
 # DEALINGS IN THE SOFTWARE.
 
 import argparse
+import asyncio
+from collections import namedtuple
+from functools import reduce
+
+
 import bittensor
 from rich.table import Table
+
 from .utils import check_netuid_set
 
 console = bittensor.__console__  # type: ignore
@@ -82,6 +88,84 @@ def run(cli: "bittensor.cli"):
                 subtensor.close()
                 bittensor.logging.debug("closing subtensor connection")
 
+    @staticmethod
+    async def commander_run(
+        subtensor: "bittensor.subtensor", config
+    ) -> dict:  # find out what netuid is
+        def reducer(x, uid):
+            ep = metagraph.axons[uid]
+            new_row = [
+                str(metagraph.neurons[uid].uid),
+                "{:.5f}".format(metagraph.total_stake[uid]),
+                "{:.5f}".format(metagraph.ranks[uid]),
+                "{:.5f}".format(metagraph.trust[uid]),
+                "{:.5f}".format(metagraph.consensus[uid]),
+                "{:.5f}".format(metagraph.incentive[uid]),
+                "{:.5f}".format(metagraph.dividends[uid]),
+                "{}".format(int(metagraph.emission[uid] * 1000000000)),
+                "{:.5f}".format(metagraph.validator_trust[uid]),
+                "*" if metagraph.validator_permit[uid] else "",
+                str((metagraph.block.item() - metagraph.last_update[uid].item())),
+                str(metagraph.active[uid].item()),
+                (
+                    ep.ip + ":" + str(ep.port)
+                    if ep.is_serving
+                    else "[yellow]none[/yellow]"
+                ),
+                ep.hotkey[:10],
+                ep.coldkey[:10],
+            ]
+            return [
+                x[0] + [new_row] if x[0] else [new_row],  # rows
+                x[1] + metagraph.total_stake[uid],  # total_stake
+                x[2] + metagraph.ranks[uid],  # total_rank
+                x[3] + metagraph.validator_trust[uid],  # total_validator_trust
+                x[4] + metagraph.trust[uid],  # total_trust
+                x[5] + metagraph.consensus[uid],  # total_consensus
+                x[6] + metagraph.incentive[uid],  # total_incentive
+                x[7] + metagraph.dividends[uid],  # total_dividends
+                x[8] + int(metagraph.emission[uid] * 1000000000),  # total_emission
+            ]
+
+        netuid = config.netuid
+        metagraph: bittensor.metagraph = await asyncio.get_event_loop().run_in_executor(
+            None, subtensor.metagraph, netuid
+        )
+        metagraph.save()
+        TableData = namedtuple(
+            "TableData",
+            [
+                "rows",
+                "total_stake",
+                "total_rank",
+                "total_validator_trust",
+                "total_trust",
+                "total_consensus",
+                "total_incentive",
+                "total_dividends",
+                "total_emission",
+                "total_neurons",
+                "difficulty",
+                "subnet_emission",
+                "total_issuance",
+            ],
+        )
+        table = TableData(
+            *(
+                reduce(
+                    reducer, metagraph.uids, [[], 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0]
+                )
+            ),
+            len(metagraph.uids),
+            subtensor.difficulty(netuid),
+            bittensor.Balance.from_tao(
+                subtensor.get_emission_value_by_subnet(netuid)
+            ).to_dict(),
+            bittensor.Balance.from_rao(subtensor.total_issuance().rao).to_dict()
+        )
+        return table._asdict()
+
+    @staticmethod
     def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"):
         r"""Prints an entire metagraph."""
         console = bittensor.__console__

bittensor/commands/network.py

@@ -15,6 +15,7 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 # DEALINGS IN THE SOFTWARE.
 
+import asyncio
 import argparse
 import bittensor
 from . import defaults
@@ -72,6 +73,19 @@ def run(cli: "bittensor.cli"):
                 subtensor.close()
                 bittensor.logging.debug("closing subtensor connection")
 
+    @staticmethod
+    async def commander_run(subtensor: "bittensor.subtensor", config):
+        success = subtensor.register_subnetwork(wallet=config.wallet, prompt=False)
+        # todo investigate why this isn't working
+        if success:
+            # todo params
+            # if config.get("set_identity"):
+            #     subtensor.close()
+            # # TODO set identity when set_identity is true
+            return {"success": True}
+        else:
+            return {"success": False}
+
     @staticmethod
     def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"):
         r"""Register a subnetwork"""
@@ -159,6 +173,12 @@ def run(cli: "bittensor.cli"):
                 subtensor.close()
                 bittensor.logging.debug("closing subtensor connection")
 
+    @staticmethod
+    async def commander_run(subtensor: "bittensor.subtensor", config):
+        return bittensor.utils.balance.Balance(
+            subtensor.get_subnet_burn_cost()
+        ).to_dict()
+
     @staticmethod
     def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"):
         r"""View locking cost of creating a new subnetwork"""
@@ -235,6 +255,38 @@ def run(cli: "bittensor.cli"):
                 subtensor.close()
                 bittensor.logging.debug("closing subtensor connection")
 
+    @staticmethod
+    async def commander_run(
+        subtensor: "bittensor.subtensor", config
+    ) -> List[List[str]]:
+        subnets: List[bittensor.SubnetInfo]
+        delegate_info: Optional[Dict[str, DelegatesDetails]]
+        event_loop = asyncio.get_event_loop()
+        subnets, delegate_info = await asyncio.gather(
+            event_loop.run_in_executor(None, subtensor.get_all_subnets_info),
+            event_loop.run_in_executor(
+                None,
+                lambda: get_delegates_details(url=bittensor.__delegates_details_url__),
+            ),
+        )
+        structure = [
+            ["NETUID", "N", "MAX_N", "EMISSION", "TEMPO", "BURN", "POW", "SUDO"]
+            + [
+                [
+                    str(s.netuid),
+                    str(s.subnetwork_n),
+                    bittensor.utils.formatting.millify(s.max_n),
+                    f"{s.emission_value / bittensor.utils.RAOPERTAO * 100:0.2f}%",
+                    str(s.tempo),
+                    str(s.burn),
+                    str(bittensor.utils.formatting.millify(s.difficulty)),
+                    f"{delegate_info[s.owner_ss58].name if s.owner_ss58 in delegate_info else s.owner_ss58}",
+                ]
+                for s in subnets
+            ]
+        ]
+        return structure
+
     @staticmethod
     def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"):
         r"""List all subnet netuids in the network."""
@@ -470,6 +522,13 @@ def run(cli: "bittensor.cli"):
                 subtensor.close()
                 bittensor.logging.debug("closing subtensor connection")
 
+    @staticmethod
+    async def commander_run(subtensor: "bittensor.subtensor", config) -> dict:
+        subnet: bittensor.SubnetHyperparameters = subtensor.get_subnet_hyperparameters(
+            config.netuid
+        )
+        return subnet.__dict__
+
     @staticmethod
     def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"):
         r"""View hyperparameters of a subnetwork."""

bittensor/commands/register.py

@@ -204,6 +204,27 @@ def run(cli: "bittensor.cli"):
                 subtensor.close()
                 bittensor.logging.debug("closing subtensor connection")
 
+    @staticmethod
+    async def commander_run(subtensor: "bittensor.subtensor", config):
+        # TODO figure out what tpb is
+        if not subtensor.subnet_exists(netuid=config.get("netuid")):
+            return {"success": False, "msg": f"Subnet {netuid} does not exist"}
+
+        registered = subtensor.register(
+            wallet=config.get("wallet"),
+            netuid=config.get("netuid"),
+            prompt=False,
+            tpb=config.get("tpb"),
+            update_interval=config.get("update_interval"),
+            num_processes=config.get(
+                "num_processes", None
+            ),  # TODO look over these as they need to come from POW reg
+            cuda=config.get("cuda"),
+            dev_id=config.get("dev_id"),
+            # TODO output in place and log verbose
+        )
+        return {"success": True, "msg": registered}
+
     @staticmethod
     def _run(cli: "bittensor.cli", subtensor: "bittensor.subtensor"):
         r"""Register neuron."""