PyPlumIO 0.6.3__tar.gz → 0.6.4__tar.gz

{pyplumio-0.6.3 → pyplumio-0.6.4}/.pre-commit-config.yaml

@@ -3,7 +3,7 @@
 # See https://pre-commit.com/hooks.html for more hooks
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.14.0
+    rev: v0.14.4
     hooks:
       - id: ruff
         args:

{pyplumio-0.6.3 → pyplumio-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPlumIO
-Version: 0.6.3
+Version: 0.6.4
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License
@@ -32,8 +32,8 @@ Requires-Dist: numpy<3.0.0,>=2.0.0; extra == "test"
 Requires-Dist: pyserial-asyncio-fast==0.16; extra == "test"
 Requires-Dist: pytest==8.4.2; extra == "test"
 Requires-Dist: pytest-asyncio==1.2.0; extra == "test"
-Requires-Dist: ruff==0.14.1; extra == "test"
-Requires-Dist: tox==4.31.0; extra == "test"
+Requires-Dist: ruff==0.14.3; extra == "test"
+Requires-Dist: tox==4.32.0; extra == "test"
 Requires-Dist: types-pyserial==3.5.0.20251001; extra == "test"
 Provides-Extra: docs
 Requires-Dist: sphinx==8.1.3; extra == "docs"

{pyplumio-0.6.3 → pyplumio-0.6.4}/PyPlumIO.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: PyPlumIO
-Version: 0.6.3
+Version: 0.6.4
 Summary: PyPlumIO is a native ecoNET library for Plum ecoMAX controllers.
 Author-email: Denis Paavilainen <denpa@denpa.pro>
 License: MIT License
@@ -32,8 +32,8 @@ Requires-Dist: numpy<3.0.0,>=2.0.0; extra == "test"
 Requires-Dist: pyserial-asyncio-fast==0.16; extra == "test"
 Requires-Dist: pytest==8.4.2; extra == "test"
 Requires-Dist: pytest-asyncio==1.2.0; extra == "test"
-Requires-Dist: ruff==0.14.1; extra == "test"
-Requires-Dist: tox==4.31.0; extra == "test"
+Requires-Dist: ruff==0.14.3; extra == "test"
+Requires-Dist: tox==4.32.0; extra == "test"
 Requires-Dist: types-pyserial==3.5.0.20251001; extra == "test"
 Provides-Extra: docs
 Requires-Dist: sphinx==8.1.3; extra == "docs"

{pyplumio-0.6.3 → pyplumio-0.6.4}/PyPlumIO.egg-info/requires.txt

@@ -19,6 +19,6 @@ numpy<3.0.0,>=2.0.0
 pyserial-asyncio-fast==0.16
 pytest==8.4.2
 pytest-asyncio==1.2.0
-ruff==0.14.1
-tox==4.31.0
+ruff==0.14.3
+tox==4.32.0
 types-pyserial==3.5.0.20251001

{pyplumio-0.6.3 → pyplumio-0.6.4}/pyplumio/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.6.3'
-__version_tuple__ = version_tuple = (0, 6, 3)
+__version__ = version = '0.6.4'
+__version_tuple__ = version_tuple = (0, 6, 4)
 
-__commit_id__ = commit_id = 'g1c504461d'
+__commit_id__ = commit_id = 'gc17c7ed5e'

{pyplumio-0.6.3 → pyplumio-0.6.4}/pyplumio/connection.py

@@ -19,8 +19,8 @@ from pyplumio.utils import timeout
 
 _LOGGER = logging.getLogger(__name__)
 
-CONNECT_TIMEOUT: Final = 5
-RECONNECT_TIMEOUT: Final = 20
+TRY_CONNECT_FOR_SECONDS: Final = 5
+RECONNECT_AFTER_SECONDS: Final = 20
 
 try:
     import serial_asyncio_fast as pyserial_asyncio
@@ -88,9 +88,9 @@ class Connection(ABC, TaskManager):
         except ConnectionFailedError:
             _LOGGER.error(
                 "Can't connect to the device, retrying in %.1f seconds",
-                RECONNECT_TIMEOUT,
+                RECONNECT_AFTER_SECONDS,
             )
-            await asyncio.sleep(RECONNECT_TIMEOUT)
+            await asyncio.sleep(RECONNECT_AFTER_SECONDS)
             self.create_task(self._reconnect(), name="reconnect_task")
 
     async def connect(self) -> None:
@@ -126,7 +126,7 @@ class Connection(ABC, TaskManager):
         """Return connection options."""
         return self._options
 
-    @timeout(CONNECT_TIMEOUT)
+    @timeout(TRY_CONNECT_FOR_SECONDS)
     @abstractmethod
     async def _open_connection(
         self,
@@ -162,7 +162,7 @@ class TcpConnection(Connection):
             f"TcpConnection(host={self.host}, port={self.port}, options={self.options})"
         )
 
-    @timeout(CONNECT_TIMEOUT)
+    @timeout(TRY_CONNECT_FOR_SECONDS)
     async def _open_connection(
         self,
     ) -> tuple[asyncio.StreamReader, asyncio.StreamWriter]:
@@ -203,7 +203,7 @@ class SerialConnection(Connection):
             f"options={self.options})"
         )
 
-    @timeout(CONNECT_TIMEOUT)
+    @timeout(TRY_CONNECT_FOR_SECONDS)
     async def _open_connection(
         self,
     ) -> tuple[asyncio.StreamReader, asyncio.StreamWriter]:

{pyplumio-0.6.3 → pyplumio-0.6.4}/pyplumio/devices/__init__.py

@@ -52,14 +52,18 @@ def get_device_handler(device_type: int) -> str:
 class Device(ABC, EventManager):
     """Represents a device."""
 
-    __slots__ = ("queue",)
+    __slots__ = ("_write_queue",)
 
-    queue: asyncio.Queue[Frame]
+    _write_queue: asyncio.Queue[Frame]
 
-    def __init__(self, queue: asyncio.Queue[Frame]) -> None:
+    def __init__(self, write_queue: asyncio.Queue[Frame]) -> None:
         """Initialize a new device."""
         super().__init__()
-        self.queue = queue
+        self._write_queue = write_queue
+
+    def queue_send(self, frame: Frame) -> None:
+        """Send frame to the write queue."""
+        self._write_queue.put_nowait(frame)
 
     async def set(
         self,
@@ -130,17 +134,19 @@ class PhysicalDevice(Device, ABC):
     virtual devices associated with them via parent property.
     """
 
-    __slots__ = ("address", "_network", "_frame_versions")
+    __slots__ = ("address", "_network_info", "_frame_versions")
 
     address: ClassVar[int]
 
-    _network: NetworkInfo
+    _network_info: NetworkInfo
     _frame_versions: dict[int, int]
 
-    def __init__(self, queue: asyncio.Queue[Frame], network: NetworkInfo) -> None:
+    def __init__(
+        self, write_queue: asyncio.Queue[Frame], network_info: NetworkInfo
+    ) -> None:
         """Initialize a new physical device."""
-        super().__init__(queue)
-        self._network = network
+        super().__init__(write_queue)
+        self._network_info = network_info
         self._frame_versions = {}
 
     @event_listener(filter=on_change)
@@ -167,7 +173,7 @@ class PhysicalDevice(Device, ABC):
         """Request frame version from the device."""
         _LOGGER.debug("Updating frame %s to version %i", repr(frame_type), version)
         request = await Request.create(frame_type, recipient=self.address)
-        self.queue.put_nowait(request)
+        self.queue_send(request)
 
     def has_frame_version(self, frame_type: FrameType | int, version: int) -> bool:
         """Return True if frame data is up to date, False otherwise."""
@@ -199,7 +205,7 @@ class PhysicalDevice(Device, ABC):
         initial_retries = retries
         while retries > 0:
             try:
-                self.queue.put_nowait(request)
+                self.queue_send(request)
                 return await self.get(name, timeout=timeout)
             except asyncio.TimeoutError:
                 retries -= 1
@@ -211,7 +217,7 @@ class PhysicalDevice(Device, ABC):
         )
 
     @classmethod
-    async def create(cls, device_type: int, **kwargs: Any) -> PhysicalDevice:
+    async def create(cls, device_type: DeviceType, **kwargs: Any) -> PhysicalDevice:
         """Create a physical device handler object."""
         return await create_instance(get_device_handler(device_type), cls=cls, **kwargs)
 
@@ -225,10 +231,10 @@ class VirtualDevice(Device, ABC):
     index: int
 
     def __init__(
-        self, queue: asyncio.Queue[Frame], parent: PhysicalDevice, index: int = 0
+        self, write_queue: asyncio.Queue[Frame], parent: PhysicalDevice, index: int = 0
     ) -> None:
         """Initialize a new sub-device."""
-        super().__init__(queue)
+        super().__init__(write_queue)
         self.parent = parent
         self.index = index
 

{pyplumio-0.6.3 → pyplumio-0.6.4}/pyplumio/devices/ecomax.py

@@ -42,7 +42,7 @@ from pyplumio.structures.ecomax_parameters import (
     ATTR_ECOMAX_PARAMETERS,
 )
 from pyplumio.structures.mixer_parameters import ATTR_MIXER_PARAMETERS
-from pyplumio.structures.network_info import ATTR_NETWORK, NetworkInfo
+from pyplumio.structures.network_info import ATTR_NETWORK_INFO, NetworkInfo
 from pyplumio.structures.product_info import ATTR_PRODUCT, ProductInfo
 from pyplumio.structures.regulator_data_schema import ATTR_REGDATA_SCHEMA
 from pyplumio.structures.schedules import (
@@ -121,7 +121,7 @@ REQUIRED_KEYS: tuple[DataKey, ...] = (
 
 REQUIRED_TYPES = [frame_type for _, frame_type in REQUIRED_KEYS]
 
-SETUP_TIMEOUT: Final = 60.0
+WAIT_FOR_SETUP_SECONDS: Final = 60.0
 
 
 @device_handler(DeviceType.ECOMAX)
@@ -132,34 +132,38 @@ class EcoMAX(PhysicalDevice):
 
     _fuel_meter: FuelMeter
 
-    def __init__(self, queue: asyncio.Queue[Frame], network: NetworkInfo) -> None:
+    def __init__(
+        self, write_queue: asyncio.Queue[Frame], network_info: NetworkInfo
+    ) -> None:
         """Initialize a new ecoMAX controller."""
-        super().__init__(queue, network)
+        super().__init__(write_queue, network_info)
         self._fuel_meter = FuelMeter()
 
     def handle_frame(self, frame: Frame) -> None:
         """Handle frame received from the ecoMAX device."""
         if isinstance(frame, Request) and (
-            response := frame.response(data={ATTR_NETWORK: self._network})
+            response := frame.response(data={ATTR_NETWORK_INFO: self._network_info})
         ):
-            self.queue.put_nowait(response)
+            self.queue_send(response)
 
         super().handle_frame(frame)
 
     def _mixers(self, indexes: Iterable[int]) -> Generator[Mixer]:
-        """Iterate through the mixer indexes.
+        """Iterate through indexes and yield a Mixer instance.
 
         For each index, return or create an instance of the mixer class.
         Once done, dispatch the 'mixers' event without waiting.
         """
         mixers: dict[int, Mixer] = self._data.setdefault(ATTR_MIXERS, {})
         for index in indexes:
-            yield mixers.setdefault(index, Mixer(self.queue, parent=self, index=index))
+            yield mixers.setdefault(
+                index, Mixer(self._write_queue, parent=self, index=index)
+            )
 
         return self.dispatch_nowait(ATTR_MIXERS, mixers)
 
     def _thermostats(self, indexes: Iterable[int]) -> Generator[Thermostat]:
-        """Iterate through the thermostat indexes.
+        """Iterate through indexes and yield a Thermostat instance.
 
         For each index, return or create an instance of the thermostat
         class. Once done, dispatch the 'thermostats' event without
@@ -168,7 +172,7 @@ class EcoMAX(PhysicalDevice):
         thermostats: dict[int, Thermostat] = self._data.setdefault(ATTR_THERMOSTATS, {})
         for index in indexes:
             yield thermostats.setdefault(
-                index, Thermostat(self.queue, parent=self, index=index)
+                index, Thermostat(self._write_queue, parent=self, index=index)
             )
 
         return self.dispatch_nowait(ATTR_THERMOSTATS, thermostats)
@@ -220,11 +224,11 @@ class EcoMAX(PhysicalDevice):
         _LOGGER.debug("Setting up device entry")
 
         try:
-            await self.wait_for(ATTR_SENSORS, timeout=SETUP_TIMEOUT)
+            await self.wait_for(ATTR_SENSORS, timeout=WAIT_FOR_SETUP_SECONDS)
         except asyncio.TimeoutError:
             _LOGGER.error(
                 "Could not setup device entry; no response from device for %u seconds",
-                SETUP_TIMEOUT,
+                WAIT_FOR_SETUP_SECONDS,
             )
             return False
 

{pyplumio-0.6.3 → pyplumio-0.6.4}/pyplumio/parameters/__init__.py

@@ -204,7 +204,7 @@ class Parameter(ABC):
         self._values = replace(self._values, value=value)
         request = await self.create_request()
         if self.description.optimistic:
-            await self.device.queue.put(request)
+            self.device.queue_send(request)
             return True
 
         self.update_done.clear()
@@ -233,7 +233,7 @@ class Parameter(ABC):
 
     async def _send_update_request(self, request: Request, timeout: float) -> bool:
         """Send update request to the remote and confirm the result."""
-        await self.device.queue.put(request)
+        self.device.queue_send(request)
         with suppress(asyncio.TimeoutError):
             # Wait for the update to be done
             await asyncio.wait_for(self.update_done.wait(), timeout=timeout)

{pyplumio-0.6.3 → pyplumio-0.6.4}/pyplumio/protocol.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 import asyncio
 from collections.abc import Awaitable, Callable
+from contextlib import suppress
 from dataclasses import dataclass, field
 from datetime import datetime
 import logging
@@ -46,7 +47,7 @@ class Protocol(ABC):
         self.writer = None
         self._on_connection_lost = set()
 
-    async def close_writer(self) -> None:
+    async def _close_writer(self) -> None:
         """Ensure that writer is closed."""
         if self.writer:
             await self.writer.close()
@@ -91,26 +92,14 @@ class DummyProtocol(Protocol):
         """Close writer and call connection lost callbacks."""
         if self.connected.is_set():
             self.connected.clear()
-            await self.close_writer()
+            await self._close_writer()
             await asyncio.gather(*(callback() for callback in self.on_connection_lost))
 
     async def shutdown(self) -> None:
         """Shutdown the protocol."""
         if self.connected.is_set():
             self.connected.clear()
-            await self.close_writer()
-
-
-@dataclass(slots=True)
-class Queues:
-    """Represents asyncio queues."""
-
-    read: asyncio.Queue[Frame] = field(default_factory=asyncio.Queue)
-    write: asyncio.Queue[Frame] = field(default_factory=asyncio.Queue)
-
-    async def join(self) -> None:
-        """Wait for queues to finish."""
-        await asyncio.gather(self.read.join(), self.write.join())
+            await self._close_writer()
 
 
 NEVER: Final = "never"
@@ -194,7 +183,7 @@ class DeviceStatistics:
         """Return a hash of the statistics based on unique address."""
         return self.address
 
-    async def update_last_seen(self, _: Any) -> None:
+    async def update_last_seen(self, _: Any | None = None) -> None:
         """Update last seen property."""
         self.last_seen = datetime.now()
 
@@ -202,41 +191,34 @@ class DeviceStatistics:
 class AsyncProtocol(Protocol, EventManager[PhysicalDevice]):
     """Represents an async protocol.
 
-    This protocol implements producer-consumers pattern using
-    asyncio queues.
-
-    The frame producer tries to read frames from the write queue.
-    If any is available, it sends them to the device via frame writer.
+    This protocol implements frame handling using a single task and
+    write queue.
 
-    It then reads stream via frame reader and puts received frame
-    into the read queue.
+    The frame handler processes frames in both directions:
+    - Sends frames from the write queue to the device via frame writer
+    - Reads incoming frames via frame reader and processes them
 
-    Frame consumers read frames from the read queue, create device
-    entry, if needed, and send frame to the entry for the processing.
+    Each received frame is passed to appropriate device handler for
+    further processing.
     """
 
-    consumers_count: int
-    _network: NetworkInfo
-    _queues: Queues
-    _entry_lock: asyncio.Lock
+    _network_info: NetworkInfo
+    _write_queue: asyncio.Queue[Frame]
     _statistics: Statistics
 
     def __init__(
         self,
         ethernet_parameters: EthernetParameters | None = None,
         wireless_parameters: WirelessParameters | None = None,
-        consumers_count: int = 3,
     ) -> None:
         """Initialize a new async protocol."""
         super().__init__()
-        self.consumers_count = consumers_count
-        self._network = NetworkInfo(
-            eth=ethernet_parameters or EthernetParameters(status=False),
-            wlan=wireless_parameters or WirelessParameters(status=False),
+        self._network_info = NetworkInfo(
+            ethernet=ethernet_parameters or EthernetParameters(status=False),
+            wireless=wireless_parameters or WirelessParameters(status=False),
         )
-        self._entry_lock = asyncio.Lock()
+        self._write_queue = asyncio.Queue()
         self._statistics = Statistics()
-        self._queues = Queues()
 
     def connection_established(
         self, reader: asyncio.StreamReader, writer: asyncio.StreamWriter
@@ -244,17 +226,11 @@ class AsyncProtocol(Protocol, EventManager[PhysicalDevice]):
         """Start frame producer and consumers."""
         self.reader = FrameReader(reader)
         self.writer = FrameWriter(writer)
-        self._queues.write.put_nowait(StartMasterRequest(recipient=DeviceType.ECOMAX))
+        self._write_queue.put_nowait(StartMasterRequest(recipient=DeviceType.ECOMAX))
         self.create_task(
-            self.frame_producer(self._queues, reader=self.reader, writer=self.writer),
-            name="frame_producer_task",
+            self.frame_handler(reader=self.reader, writer=self.writer),
+            name="frame_handler_task",
         )
-        for consumer_id in range(self.consumers_count):
-            self.create_task(
-                self.frame_consumer(self._queues.read),
-                name=f"frame_consumer_task ({consumer_id})",
-            )
-
         for device in self.data.values():
             device.dispatch_nowait(ATTR_CONNECTED, True)
 
@@ -262,57 +238,57 @@ class AsyncProtocol(Protocol, EventManager[PhysicalDevice]):
         self.statistics.reset_transfer_statistics()
         self.statistics.connected_since = datetime.now()
 
-    async def _connection_close(self) -> None:
-        """Close the connection if it is established."""
+    async def _mark_disconnected(self) -> None:
+        """Mark as protocol as disconnected."""
         self.connected.clear()
-        await asyncio.gather(
-            *(device.dispatch(ATTR_CONNECTED, False) for device in self.data.values())
-        )
-        await self.close_writer()
+        for device in self.data.values():
+            device.dispatch_nowait(ATTR_CONNECTED, False)
+
+    def _clear_write_queue(self) -> None:
+        """Clear the write queue."""
+        with suppress(asyncio.QueueEmpty):
+            while not self._write_queue.empty():
+                self._write_queue.get_nowait()
+                self._write_queue.task_done()
 
     async def connection_lost(self) -> None:
         """Close the connection and call connection lost callbacks."""
         if self.connected.is_set():
-            await self._connection_close()
+            await self._mark_disconnected()
             await asyncio.gather(*(callback() for callback in self.on_connection_lost))
+            await self._close_writer()
 
     async def shutdown(self) -> None:
         """Shutdown the protocol and close the connection."""
-        await self._queues.join()
-        self.cancel_tasks()
-        await self.wait_until_done()
         if self.connected.is_set():
-            await self._connection_close()
+            await self._mark_disconnected()
             await asyncio.gather(*(device.shutdown() for device in self.data.values()))
+            await self._close_writer()
 
-    async def _write_from_queue(
-        self, writer: FrameWriter, queue: asyncio.Queue[Frame]
-    ) -> None:
-        """Send frame from the queue to the remote device."""
-        frame = await queue.get()
-        await writer.write(frame)
-        queue.task_done()
-        self.statistics.update_sent(frame)
-
-    async def _read_into_queue(
-        self, reader: FrameReader, queue: asyncio.Queue[Frame]
-    ) -> None:
-        """Read frame from the remote device into the queue."""
-        if frame := await reader.read():
-            queue.put_nowait(frame)
-            self.statistics.update_received(frame)
+        self._clear_write_queue()
+        self.cancel_tasks()
+        await self.wait_until_done()
 
-    async def frame_producer(
-        self, queues: Queues, reader: FrameReader, writer: FrameWriter
-    ) -> None:
+    async def frame_handler(self, reader: FrameReader, writer: FrameWriter) -> None:
         """Handle frame reads and writes."""
         await self.connected.wait()
         while self.connected.is_set():
             try:
-                if not queues.write.empty():
-                    await self._write_from_queue(writer, queues.write)
+                frame: Frame | None
+
+                # Handle pending writes.
+                if not self._write_queue.empty():
+                    frame = await self._write_queue.get()
+                    await writer.write(frame)
+                    self._write_queue.task_done()
+                    self.statistics.update_sent(frame)
+
+                # Read and process frame.
+                if frame := await reader.read():
+                    self.statistics.update_received(frame)
+                    device = await self._get_device_entry(frame.sender)
+                    device.handle_frame(frame)
 
-                await self._read_into_queue(reader, queues.read)
             except ProtocolError as e:
                 self.statistics.failed_frames += 1
                 _LOGGER.debug("Can't process received frame: %s", e)
@@ -323,36 +299,29 @@ class AsyncProtocol(Protocol, EventManager[PhysicalDevice]):
             except Exception:
                 _LOGGER.exception("Unexpected exception")
 
-    async def frame_consumer(self, queue: asyncio.Queue[Frame]) -> None:
-        """Handle frame processing."""
-        await self.connected.wait()
-        while self.connected.is_set():
-            frame = await queue.get()
-            device = await self.get_device_entry(frame.sender)
-            device.handle_frame(frame)
-            queue.task_done()
-
     @acache
-    async def get_device_entry(self, device_type: DeviceType) -> PhysicalDevice:
+    async def _get_device_entry(self, device_type: DeviceType) -> PhysicalDevice:
         """Return the device entry."""
         name = device_type.name.lower()
-        async with self._entry_lock:
-            if name not in self.data:
-                device = await PhysicalDevice.create(
-                    device_type, queue=self._queues.write, network=self._network
-                )
-                device.dispatch_nowait(ATTR_CONNECTED, True)
-                device.dispatch_nowait(ATTR_SETUP, True)
-                await self.dispatch(name, device)
-                self.statistics.update_devices(device)
-
-        return self.data[name]
+        device = await PhysicalDevice.create(
+            device_type, write_queue=self._write_queue, network_info=self._network_info
+        )
+        device.dispatch_nowait(ATTR_CONNECTED, True)
+        device.dispatch_nowait(ATTR_SETUP, True)
+        await self.dispatch(name, device)
+        self.statistics.update_devices(device)
+        return device
 
     @property
     def statistics(self) -> Statistics:
         """Return the statistics."""
         return self._statistics
 
+    @property
+    def network_info(self) -> NetworkInfo:
+        """Return the network info."""
+        return self._network_info
+
 
 __all__ = [
     "Protocol",

{pyplumio-0.6.3 → pyplumio-0.6.4}/pyplumio/stream.py

@@ -22,8 +22,9 @@ from pyplumio.frames import (
 )
 from pyplumio.utils import timeout
 
-READER_TIMEOUT: Final = 10
-WRITER_TIMEOUT: Final = 10
+WAIT_FOR_READ_SECONDS: Final = 10
+WAIT_FOR_WRITE_SECONDS: Final = 10
+FORCE_CLOSE_AFTER_SECONDS: Final = 10
 
 MIN_FRAME_LENGTH: Final = 10
 MAX_FRAME_LENGTH: Final = 1000
@@ -44,7 +45,7 @@ class FrameWriter:
         """Initialize a new frame writer."""
         self._writer = writer
 
-    @timeout(WRITER_TIMEOUT)
+    @timeout(WAIT_FOR_WRITE_SECONDS)
     async def write(self, frame: Frame) -> None:
         """Send the frame and wait until send buffer is empty."""
         self._writer.write(frame.bytes)
@@ -61,7 +62,7 @@ class FrameWriter:
                 "Failed to close the frame writer due to an unexpected error"
             )
 
-    @timeout(WRITER_TIMEOUT)
+    @timeout(FORCE_CLOSE_AFTER_SECONDS)
     async def wait_closed(self) -> None:
         """Wait until the frame writer is closed."""
         await self._writer.wait_closed()
@@ -188,7 +189,7 @@ class FrameReader:
 
             await self._reader.read_into_buffer(MAX_FRAME_LENGTH)
 
-    @timeout(READER_TIMEOUT)
+    @timeout(WAIT_FOR_READ_SECONDS)
     async def read(self) -> Frame | None:
         """Read the frame and return corresponding handler object."""
         header = await self._read_header()