Rate Limiting

import time
import threading
import os

try:
    from telnyx import Telnyx
except ImportError:
    Telnyx = None


class RateLimiter:
    """Token bucket rate limiter for SMS sending."""

    def __init__(self, rate: float, burst: int | None = None):
        """
        Args:
            rate: Messages per second (e.g., 0.1 for long code, 20 for toll-free).
            burst: Max burst size. Defaults to rate (no bursting).
        """
        self.rate = rate
        self.burst = burst or max(1, int(rate))
        self.tokens = self.burst
        self.last_refill = time.monotonic()
        self.lock = threading.Lock()

    def acquire(self, timeout: float = 30.0) -> bool:
        """Wait until a token is available. Returns False on timeout."""
        deadline = time.monotonic() + timeout
        while True:
            with self.lock:
                self._refill()
                if self.tokens >= 1:
                    self.tokens -= 1
                    return True
            wait_time = min(1.0 / self.rate, deadline - time.monotonic())
            if wait_time <= 0:
                return False
            time.sleep(wait_time)

    def _refill(self):
        now = time.monotonic()
        elapsed = now - self.last_refill
        self.tokens = min(self.burst, self.tokens + elapsed * self.rate)
        self.last_refill = now


# Usage: Toll-Free at 20 MPS
limiter = RateLimiter(rate=20)

if Telnyx:
    client = Telnyx(api_key=os.environ.get("TELNYX_API_KEY"))

recipients = ["+15551234567", "+15559876543"]  # your recipient list

for to_number in recipients:
    if not limiter.acquire(timeout=60):
        print(f"Rate limit timeout sending to {to_number}")
        continue
    if Telnyx:
        response = client.messages.send(
            from_="+15550001111",
            to=to_number,
            text="Hello from Telnyx!",
        )
        print(f"Sent to {to_number}: {response.data.id}")

import time
import os

from telnyx import Telnyx

client = Telnyx(api_key=os.environ.get("TELNYX_API_KEY"))


def send_with_retry(to: str, from_: str, text: str, max_retries: int = 3):
    """Send a message with exponential backoff on rate limit errors."""
    for attempt in range(max_retries + 1):
        try:
            response = client.messages.send(from_=from_, to=to, text=text)
            return response
        except Exception as e:
            error_code = getattr(e, "code", None)
            if error_code == "40318":  # Queue full
                wait = min(2**attempt, 30)
                print(f"Queue full, retrying in {wait}s (attempt {attempt + 1})")
                time.sleep(wait)
            else:
                raise
    raise Exception(f"Failed to send to {to} after {max_retries} retries")