fix errors with upgrade.

cortext/dendrite.py

@@ -4,11 +4,18 @@
 from bittensor import dendrite
 import traceback
 import time
+from typing import Optional
 
 from cortext import StreamPrompting
 
 
 class CortexDendrite(dendrite):
+    def __init__(
+            self, wallet: Optional[Union[bt.wallet, bt.Keypair]] = None
+    ):
+        super().__init__(wallet)
+        self.process_time = 0
+
     async def call_stream(
             self,
             target_axon: Union[bt.AxonInfo, bt.axon],

organic.py

@@ -3,10 +3,10 @@
 import traceback
 
 from cortext.protocol import StreamPrompting, Bandwidth, IsAlive
+from cortext.dendrite import CortexDendrite
 
 
-
-async def query_miner(dendrite: bt.dendrite, axon_to_use, synapse, timeout, streaming):
+async def query_miner(dendrite: CortexDendrite, axon_to_use, synapse, timeout, streaming):
     try:
         # print(f"calling vali axon {axon_to_use} to miner uid {synapse.uid} for query {synapse.messages}")
         if streaming is False:
@@ -51,7 +51,7 @@ async def main():
 
     # This needs to be your validator wallet that is running your subnet 18 validator
     wallet = bt.wallet(name="miner", hotkey="default")
-    dendrite = bt.dendrite(wallet=wallet)
+    dendrite = CortexDendrite(wallet=wallet)
     vali_uid = meta.hotkeys.index(wallet.hotkey.ss58_address)
     axon_to_use = meta.axons[vali_uid]
     print(f"axon to use: {axon_to_use}")

validators/weight_setter.py

@@ -1,6 +1,8 @@
 import asyncio
 import concurrent
 import random
+import traceback
+
 import torch
 import time
 
@@ -455,27 +457,26 @@ async def _prompt(query_synapse: StreamPrompting, send: Send):
 
             synapse.deserialize_flag = False
             synapse.streaming = True
-            synapse.validator_uid = self.my_uid
-            synapse.block_num = self.current_block
+            synapse.validator_uid = self.my_uid or 0
+            synapse.block_num = self.current_block or 0
             uid = self.task_mgr.assign_task(query_synapse)
             if uid is None:
                 bt.logging.error("Can't create task. no available uids for now")
                 await send({"type": "http.response.body", "body": b'', "more_body": False})
                 return
             bt.logging.trace(f"task is created and uid is {uid}")
 
-            async def handle_response(responses):
+            async def handle_response(resp):
                 response_text = ''
-                for resp in responses:
-                    async for chunk in resp:
-                        if isinstance(chunk, str):
-                            await send({
-                                "type": "http.response.body",
-                                "body": chunk.encode("utf-8"),
-                                "more_body": True,
-                            })
-                            response_text += chunk
-                            bt.logging.trace(f"Streamed text: {chunk}")
+                async for chunk in resp:
+                    if isinstance(chunk, str):
+                        await send({
+                            "type": "http.response.body",
+                            "body": chunk.encode("utf-8"),
+                            "more_body": True,
+                        })
+                        response_text += chunk
+                        bt.logging.trace(f"Streamed text: {chunk}")
 
                 # Store the query and response in the shared database
                 async with self.lock:
@@ -494,11 +495,10 @@ async def handle_response(responses):
 
             axon = self.metagraph.axons[uid]
             await self.dendrite.aclose_session()
-            responses = await self.dendrite.call_stream(
+            responses = self.dendrite.call_stream(
                 target_axon=axon,
                 synapse=synapse,
                 timeout=synapse.timeout,
-                streaming=True,
             )
             return await handle_response(responses)