brawny 0.1.13__py3-none-any.whl → 0.1.22__py3-none-any.whl

brawny/scheduler/shutdown.py

@@ -22,7 +22,7 @@ from brawny.model.enums import IntentStatus, NonceStatus
 if TYPE_CHECKING:
     from brawny.config import Config
     from brawny.db.base import Database
-    from brawny._rpc.manager import RPCManager
+    from brawny._rpc.clients import ReadClient
     from brawny.tx.nonce import NonceManager
 
 logger = get_logger(__name__)
@@ -56,7 +56,7 @@ class ShutdownHandler:
         self,
         config: Config,
         db: Database | None = None,
-        rpc: RPCManager | None = None,
+        rpc: ReadClient | None = None,
         nonce_manager: NonceManager | None = None,
     ) -> None:
         """Initialize shutdown handler.
@@ -90,7 +90,7 @@ class ShutdownHandler:
         """Set database connection."""
         self._db = db
 
-    def set_rpc(self, rpc: RPCManager) -> None:
+    def set_rpc(self, rpc: ReadClient) -> None:
         """Set RPC manager."""
         self._rpc = rpc
 

brawny/script_tx.py

@@ -15,7 +15,7 @@ from brawny.tx.utils import normalize_tx_dict
 
 if TYPE_CHECKING:
     from brawny.keystore import Keystore
-    from brawny._rpc.manager import RPCManager
+    from brawny._rpc.clients import BroadcastClient
     from brawny.jobs.base import TxReceipt
 
 
@@ -28,7 +28,7 @@ class TransactionBroadcaster:
 
     def __init__(
         self,
-        rpc: "RPCManager",
+        rpc: "BroadcastClient",
         keystore: "Keystore",
         chain_id: int,
         timeout_seconds: int = 120,
@@ -278,7 +278,7 @@ _broadcaster: TransactionBroadcaster | None = None
 
 
 def _init_broadcaster(
-    rpc: "RPCManager",
+    rpc: "BroadcastClient",
     keystore: "Keystore",
     chain_id: int,
 ) -> None:

brawny/telegram.py

@@ -40,12 +40,31 @@ from __future__ import annotations
 import os  # Used by _LazyTelegram for TELEGRAM_BOT_TOKEN
 from typing import Any
 
-import requests
+import httpx
 
 from brawny.logging import get_logger
+from brawny.network_guard import allow_network_calls
 
 logger = get_logger(__name__)
 
+# Module-level HTTP client for connection pooling
+_http_client: httpx.Client | None = httpx.Client(timeout=30.0)
+
+
+def close_http_client() -> None:
+    """Close HTTP client on shutdown. Idempotent + safe in partial init."""
+    global _http_client
+    client, _http_client = _http_client, None
+    if client is not None:
+        client.close()
+
+
+def _client() -> httpx.Client:
+    """Get HTTP client, fail fast if closed."""
+    if _http_client is None:
+        raise RuntimeError("HTTP client is closed")
+    return _http_client
+
 # Telegram API limits
 MAX_MESSAGE_LENGTH = 4096
 TRUNCATION_SUFFIX = "\n...[truncated]"
@@ -74,15 +93,18 @@ class TelegramBot:
         self,
         token: str | None = None,
         timeout: int = 30,
+        default_parse_mode: str | None = "Markdown",
     ) -> None:
         """Initialize Telegram bot.
 
         Args:
             token: Bot token. Required for API calls.
             timeout: Request timeout in seconds.
+            default_parse_mode: Default parse mode when not explicitly provided.
         """
         self._token = token
         self._timeout = timeout
+        self._default_parse_mode = default_parse_mode
 
     @property
     def configured(self) -> bool:
@@ -115,11 +137,11 @@ class TelegramBot:
         params = {k: v for k, v in params.items() if v is not None}
 
         try:
-            response = requests.post(
-                f"{self.api_url}/{method}",
-                json=params,
-                timeout=self._timeout,
-            )
+            with allow_network_calls(reason="alerts"):
+                response = _client().post(
+                    f"{self.api_url}/{method}",
+                    json=params,
+                )
             response.raise_for_status()
             result = response.json()
 
@@ -134,7 +156,23 @@ class TelegramBot:
 
             return result.get("result")
 
-        except requests.exceptions.RequestException as e:
+        except httpx.TimeoutException:
+            # Don't log full URL (contains bot token)
+            logger.error(
+                "telegram.timeout",
+                method=method,
+                chat_id=chat_id,
+            )
+            return None
+        except httpx.HTTPStatusError as e:
+            logger.error(
+                "telegram.http_error",
+                method=method,
+                chat_id=chat_id,
+                status=e.response.status_code,
+            )
+            return None
+        except httpx.RequestError as e:
             logger.error(
                 "telegram.request_failed",
                 method=method,
@@ -170,6 +208,8 @@ class TelegramBot:
         Returns:
             Message object from Telegram API, or None on failure
         """
+        if parse_mode is None:
+            parse_mode = self._default_parse_mode
         return self._request(
             "sendMessage",
             chat_id=chat_id,
@@ -204,6 +244,8 @@ class TelegramBot:
         Returns:
             Message object or None
         """
+        if parse_mode is None:
+            parse_mode = self._default_parse_mode
         return self._request(
             "sendPhoto",
             chat_id=chat_id,
@@ -236,6 +278,8 @@ class TelegramBot:
         Returns:
             Message object or None
         """
+        if parse_mode is None:
+            parse_mode = self._default_parse_mode
         return self._request(
             "sendDocument",
             chat_id=chat_id,
@@ -268,6 +312,8 @@ class TelegramBot:
         Returns:
             Edited message object or None
         """
+        if parse_mode is None:
+            parse_mode = self._default_parse_mode
         return self._request(
             "editMessageText",
             chat_id=chat_id,

brawny/testing.py

@@ -88,6 +88,7 @@ def job_context(
         kv=kv or InMemoryJobKVStore(),
         job_id=job.job_id,
         rpc=rpc or MagicMock(),
+        http=MagicMock(),
         logger=MagicMock(),
         contracts=contracts,
         _db=None,

brawny/timeout.py

@@ -0,0 +1,38 @@
+"""Timeout budget helpers."""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Deadline:
+    """Monotonic deadline with child budgets.
+
+    Child deadlines may only consume remaining time; they never extend parents.
+    """
+
+    _deadline: float
+
+    @classmethod
+    def from_seconds(cls, seconds: float) -> "Deadline":
+        """Create a deadline seconds from now."""
+        now = time.monotonic()
+        return cls(now + max(0.0, seconds))
+
+    def remaining(self) -> float:
+        """Return seconds remaining (clamped at 0)."""
+        return max(0.0, self._deadline - time.monotonic())
+
+    def expired(self) -> bool:
+        """Return True if the deadline is exhausted."""
+        return self.remaining() <= 0.0
+
+    def child(self, seconds: float | None = None) -> "Deadline":
+        """Create a child deadline bounded by this deadline."""
+        now = time.monotonic()
+        parent_deadline = self._deadline
+        if seconds is None:
+            return Deadline(parent_deadline)
+        return Deadline(min(parent_deadline, now + max(0.0, seconds)))