chore: remove default retry usage and keep retry utility optional

Author: Dairus01

bittensor/core/dendrite.py

@@ -15,7 +15,7 @@
 from bittensor.core.stream import StreamingSynapse
 from bittensor.core.synapse import Synapse, TerminalInfo
 from bittensor.utils import networking
-from bittensor.utils.retry import retry_async
+
 from bittensor.utils.btlogging import logging
 from bittensor.utils.registration import torch, use_torch
 
@@ -576,29 +576,16 @@ async def call(
             self._log_outgoing_request(synapse)
 
             # Make the HTTP POST request
-            async def _make_request():
-                async with (await self.session).post(
-                    url=url,
-                    headers=synapse.to_headers(),
-                    json=synapse.model_dump(),
-                    timeout=aiohttp.ClientTimeout(total=timeout),
-                ) as response:
-                    # Extract the JSON response from the server
-                    json_response = await response.json()
-                    # Process the server response and fill synapse
-                    self.process_server_response(response, json_response, synapse)
-
-            # Retry the request if enabled
-            await retry_async(
-                _make_request,
-                retry_exceptions=(
-                    aiohttp.ClientConnectorError,
-                    asyncio.TimeoutError,
-                    aiohttp.ServerDisconnectedError,
-                    aiohttp.ServerConnectionError,
-                    aiohttp.ClientError,
-                ),
-            )
+            async with (await self.session).post(
+                url=url,
+                headers=synapse.to_headers(),
+                json=synapse.model_dump(),
+                timeout=aiohttp.ClientTimeout(total=timeout),
+            ) as response:
+                # Extract the JSON response from the server
+                json_response = await response.json()
+                # Process the server response and fill synapse
+                self.process_server_response(response, json_response, synapse)
 
             # Set process time and log the response
             synapse.dendrite.process_time = str(time.time() - start_time)  # type: ignore
@@ -678,13 +665,7 @@ async def _make_stream_request():
 
                     # Process the server response
                     self.process_server_response(response, json_response, synapse)
-            
-            # NOTE: streaming requests (`call_stream`) are intentionally NOT retried here.
-            # Async generators cannot be safely retried once they start yielding data without buffering
-            # or complex replay logic, which risks protocol side effects.
-            # To enable retries for streaming, the higher-level caller must handle the restart logic.
 
-            
             async with (await self.session).post(
                 url,
                 headers=synapse.to_headers(),

bittensor/core/subtensor.py

@@ -163,7 +163,7 @@
     price_to_tick,
     tick_to_price,
 )
-from bittensor.utils.retry import retry_call
+
 
 if TYPE_CHECKING:
     from async_substrate_interface.sync_substrate import QueryMapResult
@@ -564,19 +564,11 @@ def get_hyperparameter(
             logging.error(f"subnet {netuid} does not exist")
             return None
 
-        result = retry_call(
-            self.substrate.query,
+        result = self.substrate.query(
             module="SubtensorModule",
             storage_function=param_name,
             params=[netuid],
             block_hash=block_hash,
-            retry_exceptions=(
-                SubstrateRequestException,
-                ConnectionRefusedError,
-                TimeoutError,
-                BrokenPipeError,
-                ConnectionResetError,
-            ),
         )
 
         if result is None:
@@ -719,18 +711,10 @@ def query_constant(
             Common types include int (for counts/blocks), Balance objects (for amounts in Rao), and booleans.
 
         """
-        return retry_call(
-            self.substrate.get_constant,
+        return self.substrate.get_constant(
             module_name=module_name,
             constant_name=constant_name,
             block_hash=self.determine_block_hash(block),
-            retry_exceptions=(
-                SubstrateRequestException,
-                ConnectionRefusedError,
-                TimeoutError,
-                BrokenPipeError,
-                ConnectionResetError,
-            ),
         )
 
     def query_map(
@@ -754,19 +738,11 @@ def query_map(
         Returns:
             QueryMapResult: A data structure representing the map storage if found, None otherwise.
         """
-        result = retry_call(
-            self.substrate.query_map,
+        result = self.substrate.query_map(
             module=module,
             storage_function=name,
             params=params,
             block_hash=self.determine_block_hash(block=block),
-            retry_exceptions=(
-                SubstrateRequestException,
-                ConnectionRefusedError,
-                TimeoutError,
-                BrokenPipeError,
-                ConnectionResetError,
-            ),
         )
         return result
 
@@ -789,19 +765,11 @@ def query_map_subtensor(
         Returns:
             An object containing the map-like data structure, or `None` if not found.
         """
-        return retry_call(
-            self.substrate.query_map,
+        return self.substrate.query_map(
             module="SubtensorModule",
             storage_function=name,
             params=params,
             block_hash=self.determine_block_hash(block),
-            retry_exceptions=(
-                SubstrateRequestException,
-                ConnectionRefusedError,
-                TimeoutError,
-                BrokenPipeError,
-                ConnectionResetError,
-            ),
         )
 
     def query_module(
@@ -826,22 +794,13 @@ def query_module(
             An object containing the requested data if found, `None` otherwise.
 
         """
-        return retry_call(
-            self.substrate.query,
+        return self.substrate.query(
             module=module,
             storage_function=name,
             params=params,
             block_hash=self.determine_block_hash(block),
-            retry_exceptions=(
-                SubstrateRequestException,
-                ConnectionRefusedError,
-                TimeoutError,
-                BrokenPipeError,
-                ConnectionResetError,
-            ),
         )
 
-
     def query_runtime_api(
         self,
         runtime_api: str,
@@ -864,20 +823,12 @@ def query_runtime_api(
 
         """
         block_hash = self.determine_block_hash(block)
-        
-        return retry_call(
-            self.substrate.runtime_call,
+
+        return self.substrate.runtime_call(
             api=runtime_api,
             method=method,
             params=params,
             block_hash=block_hash,
-            retry_exceptions=(
-                SubstrateRequestException,
-                ConnectionRefusedError,
-                TimeoutError,
-                BrokenPipeError,
-                ConnectionResetError,
-            ),
         ).value
 
     def query_subtensor(
@@ -899,19 +850,11 @@ def query_subtensor(
         Returns:
             query_response: An object containing the requested data.
         """
-        return retry_call(
-            self.substrate.query,
+        return self.substrate.query(
             module="SubtensorModule",
             storage_function=name,
             params=params,
             block_hash=self.determine_block_hash(block),
-            retry_exceptions=(
-                SubstrateRequestException,
-                ConnectionRefusedError,
-                TimeoutError,
-                BrokenPipeError,
-                ConnectionResetError,
-            ),
         )
 
     def state_call(

bittensor/utils/retry.py

@@ -7,6 +7,10 @@
 
 logger = logging.getLogger(__name__)
 
+# Note: This utility is not used internally by the SDK.
+# It is provided as an optional helper for users who wish
+# to implement consistent retry behavior themselves.
+
 
 # Helpers for runtime environment variable access
 def _retry_enabled() -> bool: