Merge pull request #389 from macrocosm-os/staging

Staging

Author: mccrindlebrian

.gitignore

@@ -192,3 +192,4 @@ tests/mock_data
 
 db
 local-gjp
+*.ipynb

README.md

@@ -111,7 +111,7 @@ When the simulations finally converge (ΔE/t < threshold), they produce the form
 ## Requirements 
 Protein folding utilizes an open-source package called [OpenMM](https://openmm.org). To run, you will need:
 1. A Linux-based machine 
-2. At least 1 CUDA-compatible GPU. We recommend an RXT 4090. 
+2. At least 1 CUDA-compatible GPU. We recommend an RTX 4090. 
 3. Conda Distribution (we recommend [Miniconda](https://docs.anaconda.com/miniconda/)). Using conda is an [OpenMM requirement](http://docs.openmm.org/latest/userguide/application/01_getting_started.html#installing-openmm). 
 
 For more information regarding recommended hardware specifications, look at [min_compute.yml](./min_compute.yml)

folding/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "2.2.0"
+__version__ = "2.3.0"
 version_split = __version__.split(".")
 __spec_version__ = (
     (10000 * int(version_split[0]))

folding/base/miner.py

@@ -7,7 +7,7 @@
 import bittensor as bt
 
 from folding.base.neuron import BaseNeuron
-from folding.protocol import PingSynapse
+from folding.protocol import PingSynapse, ParticipationSynapse
 from folding.utils.config import add_miner_args
 from folding.utils.logger import logger
 
@@ -49,6 +49,8 @@ def __init__(self, config=None):
             priority_fn=self.priority,
         ).attach(
             forward_fn=self.ping_forward,  # not sure if we need blacklist on this.
+        ).attach(
+            forward_fn=self.participation_forward,
         )
         logger.info(f"Axon created: {self.axon}")
 
@@ -75,59 +77,16 @@ def ping_forward(self, synapse: PingSynapse):
             logger.success("Telling validator you can serve ✅")
         return synapse
 
-    def run(self):
-        """
-        Initiates and manages the main loop for the miner on the Bittensor network. The main loop handles graceful shutdown on keyboard interrupts and logs unforeseen errors.
-
-        This function performs the following primary tasks:
-        1. Check for registration on the Bittensor network.
-        2. Starts the miner's axon, making it active on the network.
-        3. Periodically resynchronizes with the chain; updating the metagraph with the latest network state and setting weights.
-
-        The miner continues its operations until `should_exit` is set to True or an external interruption occurs.
-        During each epoch of its operation, the miner waits for new blocks on the Bittensor network, updates its
-        knowledge of the network (metagraph), and sets its weights. This process ensures the miner remains active
-        and up-to-date with the network's latest state.
+    def participation_forward(self, synapse: ParticipationSynapse):
+        """Respond to the validator with the necessary information about participating in a specified job
 
-        Note:
-            - The function leverages the global configurations set during the initialization of the miner.
-            - The miner's axon serves as its interface to the Bittensor network, handling incoming and outgoing requests.
-
-        Raises:
-            KeyboardInterrupt: If the miner is stopped by a manual interruption.
-            Exception: For unforeseen errors during the miner's operation, which are logged for diagnosis.
+        Args:
+            self (ParticipationSynapse): must attach "is_participating"
         """
+        pass
 
-        # Check that miner is registered on the network.
-        self.sync()
-
-        # Serve passes the axon information to the network + netuid we are hosting on.
-        # This will auto-update if the axon port of external ip have changed.
-        logger.info(
-            f"Serving miner axon {self.axon} on network: {self.config.subtensor.chain_endpoint} with netuid: {self.config.netuid}"
-        )
-        self.axon.serve(netuid=self.config.netuid, subtensor=self.subtensor)
-
-        # Start  starts the miner's axon, making it active on the network.
-        self.axon.start()
-
-        logger.info(f"Miner starting at block: {self.block}")
-
-        # This loop maintains the miner's operations until intentionally stopped.
-        try:
-            while not self.should_exit:
-                time.sleep(10)
-                self.sync()
-
-        # If someone intentionally stops the miner, it'll safely terminate operations.
-        except KeyboardInterrupt:
-            self.axon.stop()
-            logger.success("Miner killed by keyboard interrupt.")
-            exit()
-
-        # In case of unforeseen errors, the miner will log the error and continue operations.
-        except Exception as e:
-            logger.error(traceback.format_exc())
+    def run(self):
+        pass
 
     def run_in_background_thread(self):
         """
@@ -159,6 +118,7 @@ def __enter__(self):
         This method facilitates the use of the miner in a 'with' statement.
         """
         self.run_in_background_thread()
+
         return self
 
     def __exit__(self, exc_type, exc_value, traceback):

folding/base/neuron.py

@@ -142,7 +142,8 @@ def remove_wandb_id(self, pdb_id: str):
         write_pkl(self.wandb_ids, f"{self.config.neuron.full_path}/wandb_ids.pkl", "wb")
 
     @abstractmethod
-    async def forward(self, synapse: bt.Synapse) -> bt.Synapse: ...
+    async def forward(self, synapse: bt.Synapse) -> bt.Synapse:
+        ...
 
     def sync(self):
         """