phoenix-channels-python-client 0.1.5__tar.gz → 0.2.0__tar.gz

{phoenix_channels_python_client-0.1.5/phoenix_channels_python_client.egg-info → phoenix_channels_python_client-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phoenix-channels-python-client
-Version: 0.1.5
+Version: 0.2.0
 Summary: A Python client library for connecting to Phoenix Channels
 Author: Phoenix Channels Python Client
 License-Expression: MIT

{phoenix_channels_python_client-0.1.5 → phoenix_channels_python_client-0.2.0}/phoenix_channels_python_client/__init__.py

@@ -4,19 +4,29 @@ Phoenix Channels Python Client
 A Python client library for connecting to Phoenix Channels.
 """
 
-from phoenix_channels_python_client.client import PHXChannelsClient
+from __future__ import annotations
+
+from phoenix_channels_python_client.client import (
+    DisconnectCallback,
+    PHXChannelsClient,
+    ReconnectCallback,
+    ReconnectPolicy,
+)
 from phoenix_channels_python_client.protocol_handler import (
     PHXProtocolHandler,
     PhoenixChannelsProtocolVersion,
 )
 from phoenix_channels_python_client.utils import setup_logging
 
-__version__ = "0.1.5"
+__version__ = "0.2.0"
 __author__ = "Phoenix Channels Python Client"
 
 __all__ = [
+    "DisconnectCallback",
     "PHXChannelsClient",
     "PHXProtocolHandler",
     "PhoenixChannelsProtocolVersion",
+    "ReconnectCallback",
+    "ReconnectPolicy",
     "setup_logging",
 ]

phoenix_channels_python_client-0.2.0/phoenix_channels_python_client/client.py

@@ -0,0 +1,234 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from collections import deque
+from collections.abc import Awaitable, Callable
+from types import TracebackType
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
+
+from websockets import ClientConnection
+
+from phoenix_channels_python_client.client_state_machine import transition_client_state
+from phoenix_channels_python_client.client_types import (
+    ClientState,
+    ReconnectPolicy,
+    reconnect_policy_is_invalid,
+    validate_reconnect_policy,
+)
+from phoenix_channels_python_client.exceptions import PHXConnectionError
+from phoenix_channels_python_client.protocol_handler import (
+    PHXProtocolHandler,
+    PhoenixChannelsProtocolVersion,
+)
+from phoenix_channels_python_client.reconnect_controller import ReconnectControllerMixin
+from phoenix_channels_python_client.supervisor import SupervisorMixin
+from phoenix_channels_python_client.topic_runtime import TopicRuntimeMixin
+from phoenix_channels_python_client.topic_subscription import TopicSubscription
+
+logger = logging.getLogger(__name__)
+
+ReconnectCallback = Callable[[], Awaitable[None]]
+DisconnectCallback = Callable[[Exception | None], Awaitable[None]]
+
+
+def _build_channel_socket_urls(
+    websocket_url: str, api_key: str, vsn: str
+) -> tuple[str, str]:
+    split_url = urlsplit(websocket_url)
+    query_params = parse_qsl(split_url.query, keep_blank_values=True)
+    filtered = [
+        (key, value) for key, value in query_params if key not in {"api_key", "vsn"}
+    ]
+    with_auth = [*filtered, ("api_key", api_key), ("vsn", vsn)]
+
+    connect_url = urlunsplit(
+        (
+            split_url.scheme,
+            split_url.netloc,
+            split_url.path,
+            urlencode(with_auth),
+            split_url.fragment,
+        )
+    )
+    redacted_url = urlunsplit(
+        (
+            split_url.scheme,
+            split_url.netloc,
+            split_url.path,
+            urlencode(
+                [
+                    (key, "***" if key == "api_key" else value)
+                    for key, value in with_auth
+                ]
+            ),
+            split_url.fragment,
+        )
+    )
+    return connect_url, redacted_url
+
+
+class PHXChannelsClient(SupervisorMixin, TopicRuntimeMixin, ReconnectControllerMixin):
+    def __init__(
+        self,
+        websocket_url: str,
+        api_key: str,
+        *,
+        protocol_version: PhoenixChannelsProtocolVersion = PhoenixChannelsProtocolVersion.V2,
+        auto_reconnect: bool = True,
+        reconnect_policy: ReconnectPolicy | None = None,
+        join_timeout_s: float = 10.0,
+        leave_timeout_s: float = 5.0,
+        max_topic_queue_size: int = 1000,
+        callback_drain_timeout_s: float = 2.0,
+        heartbeat_interval_s: float | None = 30.0,
+        on_reconnect: ReconnectCallback | None = None,
+        on_disconnect: DisconnectCallback | None = None,
+    ):
+        self.logger = logger
+
+        if heartbeat_interval_s is not None and heartbeat_interval_s <= 0:
+            raise ValueError("heartbeat_interval_s must be > 0 or None to disable")
+
+        if join_timeout_s <= 0:
+            raise ValueError("join_timeout_s must be > 0")
+        if leave_timeout_s <= 0:
+            raise ValueError("leave_timeout_s must be > 0")
+        if max_topic_queue_size <= 0:
+            raise ValueError("max_topic_queue_size must be > 0")
+        if callback_drain_timeout_s <= 0:
+            raise ValueError("callback_drain_timeout_s must be > 0")
+        try:
+            validate_reconnect_policy(reconnect_policy or ReconnectPolicy())
+        except ValueError as exc:
+            raise ValueError("Invalid reconnect policy configuration") from exc
+
+        vsn = (
+            "2.0.0"
+            if protocol_version == PhoenixChannelsProtocolVersion.V2
+            else "1.0.0"
+        )
+        connect_url, redacted_url = _build_channel_socket_urls(
+            websocket_url=websocket_url,
+            api_key=api_key,
+            vsn=vsn,
+        )
+        self.channel_socket_url = connect_url
+        self.channel_socket_url_redacted = redacted_url
+
+        self.auto_reconnect = auto_reconnect
+        self.reconnect_policy = reconnect_policy or ReconnectPolicy()
+        self.join_timeout_s = join_timeout_s
+        self.leave_timeout_s = leave_timeout_s
+        self.max_topic_queue_size = max_topic_queue_size
+        self.callback_drain_timeout_s = callback_drain_timeout_s
+
+        self.connection: ClientConnection | None = None
+        self._topic_subscriptions: dict[str, TopicSubscription] = {}
+        self._protocol_handler = PHXProtocolHandler(protocol_version)
+        self._ref_counter = 0
+        self._state = ClientState.CLOSED
+        self._topics_lock = asyncio.Lock()
+        self._shutdown_event = asyncio.Event()
+        self._connected_event = asyncio.Event()
+        self._conn_generation = 0
+        self._supervisor_task: asyncio.Task[None] | None = None
+        self._message_routing_task: asyncio.Task[None] | None = None
+        self._initial_connection_future: asyncio.Future[None] | None = None
+        self._rapid_disconnects: deque[float] = deque()
+        self._terminal_error: Exception | None = None
+        self._heartbeat_interval_s = heartbeat_interval_s
+        self._heartbeat_task: asyncio.Task[None] | None = None
+        self._pending_heartbeat_ref: str | None = None
+        self._on_reconnect = on_reconnect
+        self._on_disconnect = on_disconnect
+
+    @staticmethod
+    def reconnect_policy_is_invalid(policy: ReconnectPolicy) -> bool:
+        return reconnect_policy_is_invalid(policy)
+
+    async def __aenter__(self) -> PHXChannelsClient:
+        self.logger.debug("Entering PHXChannelsClient context")
+        if self._state != ClientState.CLOSED:
+            raise PHXConnectionError("Client is already running")
+
+        self._shutdown_event.clear()
+        self._connected_event.clear()
+        self._rapid_disconnects.clear()
+        self._terminal_error = None
+        self._initial_connection_future = asyncio.get_running_loop().create_future()
+        self._transition_state(ClientState.CONNECTING)
+
+        self._supervisor_task = asyncio.create_task(self._supervisor_loop())
+
+        try:
+            await self._initial_connection_future
+        except Exception:
+            await self.shutdown("Initial connection failed")
+            raise
+
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None = None,
+        exc_value: BaseException | None = None,
+        traceback: TracebackType | None = None,
+    ) -> None:
+        self.logger.debug("Leaving PHXChannelsClient context")
+        await self.shutdown("Leaving PHXChannelsClient context")
+
+    async def shutdown(
+        self,
+        reason: str,
+    ) -> None:
+        if (
+            self._state == ClientState.CLOSED
+            and not self._topic_subscriptions
+            and self.connection is None
+        ):
+            return
+
+        self.logger.info("Event loop shutting down! reason=%s", reason)
+
+        if self._state not in (ClientState.SHUTTING_DOWN, ClientState.CLOSED):
+            self._transition_state(ClientState.SHUTTING_DOWN)
+
+        self._shutdown_event.set()
+
+        topics_to_unsubscribe = list(self._topic_subscriptions.keys())
+        if topics_to_unsubscribe:
+            unsubscribe_tasks = [
+                self.unsubscribe_from_topic(topic, _allow_disconnected=True)
+                for topic in topics_to_unsubscribe
+            ]
+            results = await asyncio.gather(*unsubscribe_tasks, return_exceptions=True)
+
+            for topic, result in zip(topics_to_unsubscribe, results, strict=False):
+                if isinstance(result, Exception):
+                    self.logger.warning(
+                        "Failed to unsubscribe from topic %s during shutdown: %s",
+                        topic,
+                        result,
+                    )
+
+        if self._supervisor_task and not self._supervisor_task.done():
+            self._supervisor_task.cancel()
+            try:
+                await self._supervisor_task
+            except asyncio.CancelledError:
+                self.logger.debug("Supervisor task cancelled during shutdown")
+
+        await self._cleanup_connection()
+        self._connected_event.clear()
+        self._transition_state(ClientState.CLOSED)
+
+    def _transition_state(self, new_state: ClientState) -> None:
+        if self._state == new_state:
+            return
+
+        transitioned_state = transition_client_state(self._state, new_state)
+        self.logger.debug(
+            "Client state transition: %s -> %s", self._state.value, new_state.value
+        )
+        self._state = transitioned_state

phoenix_channels_python_client-0.2.0/phoenix_channels_python_client/client_state_machine.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from phoenix_channels_python_client.client_types import ClientState
+
+
+def transition_client_state(
+    current: ClientState, new_state: ClientState
+) -> ClientState:
+    if current == new_state:
+        return current
+
+    allowed_transitions: dict[ClientState, set[ClientState]] = {
+        ClientState.CLOSED: {ClientState.CONNECTING},
+        ClientState.CONNECTING: {
+            ClientState.CONNECTED,
+            ClientState.RECONNECTING,
+            ClientState.SHUTTING_DOWN,
+            ClientState.CLOSED,
+        },
+        ClientState.CONNECTED: {
+            ClientState.RECONNECTING,
+            ClientState.SHUTTING_DOWN,
+            ClientState.CLOSED,
+        },
+        ClientState.RECONNECTING: {
+            ClientState.CONNECTED,
+            ClientState.SHUTTING_DOWN,
+            ClientState.CLOSED,
+        },
+        ClientState.SHUTTING_DOWN: {ClientState.CLOSED},
+    }
+
+    if new_state not in allowed_transitions[current]:
+        raise RuntimeError(
+            f"Invalid state transition {current.value} -> {new_state.value}"
+        )
+
+    return new_state

phoenix_channels_python_client-0.2.0/phoenix_channels_python_client/client_types.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+from phoenix_channels_python_client.exceptions import PHXConnectionError
+
+
+class ClientState(Enum):
+    CONNECTING = "connecting"
+    CONNECTED = "connected"
+    RECONNECTING = "reconnecting"
+    SHUTTING_DOWN = "shutting_down"
+    CLOSED = "closed"
+
+
+@dataclass(frozen=True)
+class ReconnectPolicy:
+    base_delay_s: float = 0.5
+    factor: float = 2.0
+    max_delay_s: float = 30.0
+    stable_reset_s: float = 60.0
+    reconnect_on_normal_close: bool = False
+    policy_violation_is_terminal: bool = True
+    service_restart_min_delay_s: float = 1.0
+    service_restart_max_delay_s: float = 5.0
+    try_again_later_min_delay_s: float = 30.0
+    try_again_later_max_delay_s: float = 60.0
+    rapid_disconnect_uptime_s: float = 5.0
+    rapid_window_s: float = 60.0
+    rapid_first_min_delay_s: float = 2.0
+    rapid_second_min_delay_s: float = 10.0
+    rapid_cooldown_base_s: float = 60.0
+    rapid_cooldown_step_s: float = 30.0
+    rapid_cooldown_max_s: float = 300.0
+    rapid_suppress_disconnect_count: int = 10
+    rapid_hold_down_jitter_low_ratio: float = 0.25
+    rapid_hold_down_jitter_high_ratio: float = 1.0
+
+
+@dataclass(frozen=True)
+class ReconnectDecision:
+    should_reconnect: bool
+    min_delay_s: float | None = None
+    max_delay_s: float | None = None
+    terminal_error: PHXConnectionError | None = None
+
+
+def validate_reconnect_policy(policy: ReconnectPolicy) -> None:
+    if policy.base_delay_s < 0:
+        raise ValueError("base_delay_s must be >= 0")
+    if policy.factor <= 0:
+        raise ValueError("factor must be > 0")
+    if policy.max_delay_s < 0:
+        raise ValueError("max_delay_s must be >= 0")
+    if policy.stable_reset_s <= 0:
+        raise ValueError("stable_reset_s must be > 0")
+    if policy.service_restart_min_delay_s < 0:
+        raise ValueError("service_restart_min_delay_s must be >= 0")
+    if policy.service_restart_max_delay_s < policy.service_restart_min_delay_s:
+        raise ValueError(
+            "service_restart_max_delay_s must be >= service_restart_min_delay_s"
+        )
+    if policy.try_again_later_min_delay_s < 0:
+        raise ValueError("try_again_later_min_delay_s must be >= 0")
+    if policy.try_again_later_max_delay_s < policy.try_again_later_min_delay_s:
+        raise ValueError(
+            "try_again_later_max_delay_s must be >= try_again_later_min_delay_s"
+        )
+    if policy.rapid_disconnect_uptime_s < 0:
+        raise ValueError("rapid_disconnect_uptime_s must be >= 0")
+    if policy.rapid_window_s <= 0:
+        raise ValueError("rapid_window_s must be > 0")
+    if policy.rapid_first_min_delay_s < 0:
+        raise ValueError("rapid_first_min_delay_s must be >= 0")
+    if policy.rapid_second_min_delay_s < 0:
+        raise ValueError("rapid_second_min_delay_s must be >= 0")
+    if policy.rapid_cooldown_base_s < 0:
+        raise ValueError("rapid_cooldown_base_s must be >= 0")
+    if policy.rapid_cooldown_step_s < 0:
+        raise ValueError("rapid_cooldown_step_s must be >= 0")
+    if policy.rapid_cooldown_max_s < policy.rapid_cooldown_base_s:
+        raise ValueError("rapid_cooldown_max_s must be >= rapid_cooldown_base_s")
+    if policy.rapid_suppress_disconnect_count < 0:
+        raise ValueError("rapid_suppress_disconnect_count must be >= 0")
+    if policy.rapid_hold_down_jitter_low_ratio < 0:
+        raise ValueError("rapid_hold_down_jitter_low_ratio must be >= 0")
+    if (
+        policy.rapid_hold_down_jitter_high_ratio
+        < policy.rapid_hold_down_jitter_low_ratio
+    ):
+        raise ValueError(
+            "rapid_hold_down_jitter_high_ratio must be >= rapid_hold_down_jitter_low_ratio"
+        )
+
+
+def reconnect_policy_is_invalid(policy: ReconnectPolicy) -> bool:
+    try:
+        validate_reconnect_policy(policy)
+    except ValueError:
+        return True
+    return False

{phoenix_channels_python_client-0.1.5 → phoenix_channels_python_client-0.2.0}/phoenix_channels_python_client/phx_messages.py

@@ -1,41 +1,39 @@
+from __future__ import annotations
+
 from dataclasses import dataclass
 from enum import Enum, unique
 from functools import cached_property
-from typing import Any, NewType, Optional, Union
-
-
-Event = NewType("Event", str)
-ChannelEvent = Union["PHXEvent", Event]
-ChannelMessage = Union["PHXMessage", "PHXEventMessage"]
+from typing import Any, NewType
 
 
 @unique
 class PHXEvent(Enum):
-    """Phoenix Channels admin events"""
-
     close = "phx_close"
     error = "phx_error"
     join = "phx_join"
     reply = "phx_reply"
     leave = "phx_leave"
 
-    value: str
-
     def __str__(self) -> str:
         return self.value
 
 
+UserEvent = NewType("UserEvent", str)
+# Compatibility alias for existing imports and call sites.
+Event = UserEvent
+ChannelEvent = PHXEvent | UserEvent
+
+
 @dataclass(frozen=True)
 class BasePHXMessage:
     topic: str
-    ref: Optional[str]
+    ref: str | None
     payload: dict[str, Any]
 
     @cached_property
-    def subtopic(self) -> Optional[str]:
+    def subtopic(self) -> str | None:
         if ":" not in self.topic:
             return None
-
         _, subtopic = self.topic.split(":", 1)
         return subtopic
 
@@ -43,10 +41,15 @@ class BasePHXMessage:
 @dataclass(frozen=True)
 class PHXMessage(BasePHXMessage):
     event: Event
-    join_ref: Optional[str] = None
+    join_ref: str | None = None
 
 
 @dataclass(frozen=True)
 class PHXEventMessage(BasePHXMessage):
     event: PHXEvent
-    join_ref: Optional[str] = None
+    join_ref: str | None = None
+
+
+ChannelMessage = PHXMessage | PHXEventMessage
+# Compatibility alias for existing tests and call sites.
+Message = ChannelMessage

phoenix_channels_python_client-0.2.0/phoenix_channels_python_client/protocol_handler.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+from collections.abc import Callable
+from enum import Enum
+
+from websockets import ClientConnection
+
+from phoenix_channels_python_client.phx_messages import ChannelMessage, Event
+from phoenix_channels_python_client.topic_subscription import TopicSubscription
+from phoenix_channels_python_client.utils import make_message
+
+logger = logging.getLogger(__name__)
+
+
+class PhoenixChannelsProtocolVersion(Enum):
+    V1 = "1.0"
+    V2 = "2.0"
+
+
+class PHXProtocolHandler:
+    def __init__(
+        self,
+        protocol_version: PhoenixChannelsProtocolVersion = PhoenixChannelsProtocolVersion.V2,
+    ):
+        self.protocol_version = protocol_version
+        self.logger = logger.getChild("ProtocolHandler")
+        self.logger.debug(
+            "Initialized PHXProtocolHandler for protocol version %s",
+            self.protocol_version.value,
+        )
+
+    def parse_message(self, raw_message: str | bytes) -> ChannelMessage:
+        self.logger.debug("Parsing raw message: %s", raw_message)
+        try:
+            parsed_data = json.loads(raw_message)
+            self.logger.debug("Decoded data: %s", parsed_data)
+            if self.protocol_version == PhoenixChannelsProtocolVersion.V2:
+                if not isinstance(parsed_data, list):
+                    raise TypeError(
+                        "Protocol v2 expects array format, "
+                        f"got {type(parsed_data).__name__}"
+                    )
+                if len(parsed_data) != 5:
+                    raise ValueError(
+                        "Protocol v2 expects 5-element array "
+                        "[join_ref, ref, topic, event, payload]"
+                    )
+
+                join_ref, ref, topic, event, payload = parsed_data
+                if not isinstance(topic, str) or not topic:
+                    raise TypeError(
+                        "Protocol v2 message topic must be a non-empty string"
+                    )
+                if not isinstance(event, str) or not event:
+                    raise TypeError(
+                        "Protocol v2 message event must be a non-empty string"
+                    )
+                if payload is None or not isinstance(payload, dict):
+                    payload = {}
+
+                return make_message(
+                    topic=topic,
+                    event=Event(event),
+                    payload=payload,
+                    ref=ref if ref is None else str(ref),
+                    join_ref=join_ref if join_ref is None else str(join_ref),
+                )
+
+            if not isinstance(parsed_data, dict):
+                raise TypeError(
+                    "Protocol v1 expects object format, "
+                    f"got {type(parsed_data).__name__}"
+                )
+
+            topic = parsed_data.get("topic")
+            event = parsed_data.get("event")
+            payload = parsed_data.get("payload", {})
+            if not isinstance(topic, str) or not topic:
+                raise TypeError("Protocol v1 message topic must be a non-empty string")
+            if not isinstance(event, str) or not event:
+                raise TypeError("Protocol v1 message event must be a non-empty string")
+            if not isinstance(payload, dict):
+                payload = {}
+
+            return make_message(
+                topic=topic,
+                event=Event(event),
+                payload=payload,
+                ref=parsed_data.get("ref"),
+                join_ref=parsed_data.get("join_ref"),
+            )
+        except (TypeError, ValueError):
+            self.logger.exception("Failed to parse message")
+            raise
+        except Exception as exc:
+            self.logger.exception("Unexpected error parsing message")
+            raise ValueError(f"Invalid message format: {exc}") from exc
+
+    def serialize_message(self, message: ChannelMessage) -> str:
+        self.logger.debug("Serializing message: %s", message)
+        try:
+            if self.protocol_version == PhoenixChannelsProtocolVersion.V2:
+                serialized = json.dumps(
+                    [
+                        message.join_ref,
+                        message.ref,
+                        message.topic,
+                        str(message.event),
+                        message.payload,
+                    ]
+                )
+            else:
+                serialized = json.dumps(
+                    {
+                        "topic": message.topic,
+                        "event": str(message.event),
+                        "ref": message.ref,
+                        "payload": message.payload,
+                    }
+                )
+            self.logger.debug("Serialized to: %s", serialized)
+            return serialized
+        except Exception as exc:
+            self.logger.exception("Failed to serialize message")
+            raise TypeError(f"Cannot serialize message: {exc}") from exc
+
+    async def send_message(
+        self, websocket: ClientConnection, message: ChannelMessage
+    ) -> None:
+        self.logger.debug(
+            "Serializing %s to Phoenix Channels %s format",
+            message,
+            self.protocol_version.value,
+        )
+        text_message = self.serialize_message(message)
+
+        self.logger.debug("Sending as TEXT frame: %s", text_message)
+        await websocket.send(text_message)
+
+    async def process_websocket_messages(
+        self,
+        connection: ClientConnection,
+        topic_subscriptions: dict[str, TopicSubscription],
+        conn_generation: int,
+        on_heartbeat_response: Callable[[ChannelMessage], None] | None = None,
+    ) -> None:
+        self.logger.debug(
+            "Starting websocket message loop for generation %s", conn_generation
+        )
+        async for socket_message in connection:
+            phx_message = self.parse_message(socket_message)
+            self.logger.debug("Processing message - %s", phx_message)
+            topic = phx_message.topic
+
+            if topic == "phoenix":
+                if on_heartbeat_response is not None:
+                    on_heartbeat_response(phx_message)
+                continue
+
+            if topic not in topic_subscriptions:
+                continue
+
+            topic_subscription = topic_subscriptions[topic]
+            if topic_subscription.conn_generation != conn_generation:
+                self.logger.debug(
+                    "Dropping message for stale generation on topic %s. routing_gen=%s subscription_gen=%s",
+                    topic,
+                    conn_generation,
+                    topic_subscription.conn_generation,
+                )
+                continue
+
+            if (
+                self.protocol_version == PhoenixChannelsProtocolVersion.V2
+                and topic_subscription.join_ref != phx_message.join_ref
+            ):
+                self.logger.debug(
+                    "Dropping message with stale join_ref on topic %s. got=%s expected=%s",
+                    topic,
+                    phx_message.join_ref,
+                    topic_subscription.join_ref,
+                )
+                continue
+
+            if topic_subscription.queue.full():
+                try:
+                    topic_subscription.queue.get_nowait()
+                    topic_subscription.dropped_message_count += 1
+                    if (
+                        topic_subscription.dropped_message_count == 1
+                        or topic_subscription.dropped_message_count % 100 == 0
+                    ):
+                        self.logger.warning(
+                            "Dropped %s queued messages for topic %s due to full queue",
+                            topic_subscription.dropped_message_count,
+                            topic,
+                        )
+                except asyncio.QueueEmpty:
+                    self.logger.debug(
+                        "Queue became empty before drop on topic %s; skipping drop",
+                        topic,
+                    )
+
+            await topic_subscription.queue.put(phx_message)