microdlms 0.1.0__py3-none-any.whl

microdlms/__init__.py

@@ -0,0 +1,64 @@
+"""microdlms: Zero-core-dependency DLMS/COSEM meter client for Python 3.14+."""
+
+from __future__ import annotations
+
+from microdlms.axdr import decode_axdr
+from microdlms.client import AsyncMeterClient
+from microdlms.exceptions import (
+    AuthenticationError,
+    CommunicationError,
+    DataAccessError,
+    MicrodlmsError,
+    ProtocolError,
+)
+from microdlms.obis import CosemAttribute, ObisCode
+from microdlms.session import DlmsSession, SessionState
+from microdlms.types import (
+    AssociatedEvent,
+    AssociationDiagnostic,
+    AssociationRejectedEvent,
+    AssociationResult,
+    ConnectedEvent,
+    CosemDateTime,
+    DataAccessResult,
+    DisconnectedEvent,
+    GetAccessErrorEvent,
+    GetResponseEvent,
+    InterfaceClass,
+    ProtocolErrorEvent,
+    ReleasedEvent,
+    ScalerUnit,
+    SessionEvent,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "__version__",
+    "AsyncMeterClient",
+    "DlmsSession",
+    "SessionState",
+    "ObisCode",
+    "CosemAttribute",
+    "InterfaceClass",
+    "ScalerUnit",
+    "CosemDateTime",
+    "AssociationResult",
+    "AssociationDiagnostic",
+    "DataAccessResult",
+    "ConnectedEvent",
+    "AssociatedEvent",
+    "AssociationRejectedEvent",
+    "GetResponseEvent",
+    "GetAccessErrorEvent",
+    "ReleasedEvent",
+    "DisconnectedEvent",
+    "ProtocolErrorEvent",
+    "SessionEvent",
+    "MicrodlmsError",
+    "CommunicationError",
+    "AuthenticationError",
+    "DataAccessError",
+    "ProtocolError",
+    "decode_axdr",
+]

microdlms/apdu.py

@@ -0,0 +1,203 @@
+"""DLMS/COSEM Application Protocol Data Unit (APDU) codecs."""
+
+from __future__ import annotations
+
+from typing import Any, Final
+
+from microdlms.axdr import decode_axdr, encode_axdr_length
+from microdlms.exceptions import ProtocolError
+from microdlms.obis import CosemAttribute
+from microdlms.types import AssociationResult, DataAccessResult
+
+TAG_AARQ: Final = 0x60
+TAG_AARE: Final = 0x61
+TAG_RLRQ: Final = 0x62
+TAG_RLRE: Final = 0x63
+TAG_GET_REQUEST: Final = 0xC0
+TAG_GET_RESPONSE: Final = 0xC4
+
+# Default system title matching captured fixtures if none provided
+DEFAULT_SYSTEM_TITLE: Final = bytes.fromhex("7574691cc56a7264")
+
+# Logical Name referencing without ciphering OID: 2.16.756.5.8.1.1
+APP_CONTEXT_LN_NO_CIPHER: Final = bytes.fromhex("060760857405080101")
+
+# Low-Level Security (LLS) Mechanism name OID: 2.16.756.5.8.2.1
+MECHANISM_NAME_LLS: Final = bytes.fromhex("60857405080201")
+
+# Default proposed xDLMS InitiateRequest conformance: 00 20 52, max receive PDU 24575
+DEFAULT_INITIATE_REQUEST: Final = bytes.fromhex("01000000065f1f040020525fffff")
+
+
+def encode_aarq(
+    password: str | bytes | None = None,
+    system_title: bytes | None = None,
+) -> bytes:
+    """Encode an Application Association Request (AARQ) APDU."""
+    effective_system_title = system_title if system_title is not None else DEFAULT_SYSTEM_TITLE
+    if len(effective_system_title) != 8:
+        message = f"System title must be exactly 8 bytes, got {len(effective_system_title)}"
+        raise ValueError(message)
+
+    parts: list[bytes] = []
+
+    # 1. Application-context-name [1]
+    parts.append(b"\xa1\x09" + APP_CONTEXT_LN_NO_CIPHER)
+
+    # 2. Calling-AP-title [6]
+    parts.append(b"\xa6\x0a\x04\x08" + effective_system_title)
+
+    # 3. Authentication (Low-Level Security if password provided)
+    if password is not None:
+        password_bytes = password.encode("utf-8") if isinstance(password, str) else password
+        if len(password_bytes) > 0:
+            # ACSE requirements [10]: authentication bit
+            parts.append(b"\x8a\x02\x07\x80")
+            # Mechanism-name [11]: LLS OID
+            parts.append(b"\x8b\x07" + MECHANISM_NAME_LLS)
+            # Calling-authentication-value [12] -> [0] primitive
+            value_field = b"\x80" + encode_axdr_length(len(password_bytes)) + password_bytes
+            parts.append(b"\xac" + encode_axdr_length(len(value_field)) + value_field)
+
+    # 4. User-information [30] -> OCTET STRING wrapping xDLMS InitiateRequest
+    user_information = (
+        b"\x04" + encode_axdr_length(len(DEFAULT_INITIATE_REQUEST)) + DEFAULT_INITIATE_REQUEST
+    )
+    parts.append(b"\xbe" + encode_axdr_length(len(user_information)) + user_information)
+
+    body = b"".join(parts)
+    return bytes([TAG_AARQ]) + encode_axdr_length(len(body)) + body
+
+
+def _read_ber_tlv(data: bytes, position: int) -> tuple[int, bytes, int] | None:
+    """Read a single BER TLV element returning (tag, value_bytes, next_position) or None."""
+    if position + 2 > len(data):
+        return None
+    tag = data[position]
+    position += 1
+    length_byte = data[position]
+    position += 1
+    if length_byte < 0x80:
+        length = length_byte
+    else:
+        length_bytes_count = length_byte & 0x7F
+        if position + length_bytes_count > len(data):
+            return None
+        length = int.from_bytes(data[position : position + length_bytes_count], "big")
+        position += length_bytes_count
+
+    if position + length > len(data):
+        return None
+    chunk = data[position : position + length]
+    return tag, chunk, position + length
+
+
+def _parse_aare_result(chunk: bytes) -> AssociationResult:
+    """Parse AssociationResult enum from result field bytes."""
+    try:
+        return AssociationResult(chunk[2])
+    except ValueError, IndexError:
+        return AssociationResult.REJECTED_PERMANENT
+
+
+def _parse_aare_diagnostic(chunk: bytes) -> int:
+    """Parse diagnostic integer from result-source-diagnostic field bytes."""
+    if len(chunk) >= 5 and chunk[2] == 0x02 and chunk[3] == 0x01:
+        return chunk[4]
+    return 0
+
+
+def decode_aare(apdu: bytes) -> tuple[AssociationResult, int]:
+    """Decode an Application Association Response (AARE) APDU into (result, diagnostic)."""
+    if len(apdu) < 3 or apdu[0] != TAG_AARE:
+        message = f"Invalid AARE APDU: {apdu.hex()}"
+        raise ProtocolError(message)
+
+    position = 1
+    # Read length of AARE
+    initial_length = apdu[position]
+    position += 1
+    if initial_length >= 0x80:
+        length_bytes_count = initial_length & 0x7F
+        position += length_bytes_count
+
+    result: AssociationResult | None = None
+    diagnostic: int = 0
+
+    while position < len(apdu):
+        tlv = _read_ber_tlv(apdu, position)
+        if tlv is None:
+            break
+        tag, chunk, position = tlv
+
+        if tag == 0xA2:  # result [2]
+            result = _parse_aare_result(chunk)
+        elif tag == 0xA3:  # result-source-diagnostic [3]
+            diagnostic = _parse_aare_diagnostic(chunk)
+
+    if result is None:
+        message = f"AARE APDU missing result field: {apdu.hex()}"
+        raise ProtocolError(message)
+
+    return result, diagnostic
+
+
+def encode_get_request_normal(
+    attribute: CosemAttribute,
+    invoke_id: int = 0,
+    priority: int = 0xC0,
+) -> bytes:
+    """Encode a Get-Request-Normal APDU querying a COSEM attribute."""
+    invoke_id_byte = (priority & 0xF0) | (invoke_id & 0x0F)
+    # Tag 0xC0 (Get-Request), Choice 0x01 (Get-Request-Normal)
+    # Followed by invoke_id_and_priority (1B), attribute descriptor (9B), access_selection (1B)
+    return bytes([TAG_GET_REQUEST, 0x01, invoke_id_byte]) + attribute.to_bytes() + bytes([0x00])
+
+
+def decode_get_response_normal(apdu: bytes) -> tuple[int, bool, Any]:
+    """Decode a Get-Response-Normal APDU into (invoke_id, is_success, value_or_error_code)."""
+    if len(apdu) < 4 or apdu[0] != TAG_GET_RESPONSE:
+        message = f"Invalid Get-Response APDU: {apdu.hex()}"
+        raise ProtocolError(message)
+
+    choice = apdu[1]
+    if choice != 0x01:
+        message = f"Unsupported Get-Response type 0x{choice:02X} (only Normal=0x01 is supported)"
+        raise ProtocolError(message)
+
+    invoke_id = apdu[2] & 0x0F
+    result_type = apdu[3]
+
+    if result_type == 0x00:
+        # Success: A-XDR data follows immediately at offset 4
+        decoded_value = decode_axdr(apdu[4:])
+        return invoke_id, True, decoded_value
+
+    if result_type == 0x01:
+        # DataAccessResult error code at offset 4
+        if len(apdu) < 5:
+            message = "Get-Response-Normal error result missing error code"
+            raise ProtocolError(message)
+        try:
+            error_code = DataAccessResult(apdu[4])
+        except ValueError:
+            error_code = DataAccessResult.OTHER_REASON
+        return invoke_id, False, error_code
+
+    message = f"Unknown GetDataResult choice: 0x{result_type:02X}"
+    raise ProtocolError(message)
+
+
+def encode_rlrq(reason: int = 0) -> bytes:
+    """Encode an ACSE Release Request (RLRQ) APDU."""
+    return bytes([TAG_RLRQ, 0x03, 0x80, 0x01, reason])
+
+
+def decode_rlre(apdu: bytes) -> int:
+    """Decode an ACSE Release Response (RLRE) APDU into release reason code."""
+    if len(apdu) < 2 or apdu[0] != TAG_RLRE:
+        message = f"Invalid RLRE APDU: {apdu.hex()}"
+        raise ProtocolError(message)
+    if len(apdu) >= 5 and apdu[2] == 0x80 and apdu[3] == 0x01:
+        return apdu[4]
+    return 0

microdlms/axdr.py

@@ -0,0 +1,125 @@
+"""Linear recursive-descent A-XDR codec for DLMS/COSEM."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from microdlms.exceptions import ProtocolError
+
+_INTEGER_TAG_SPECS: dict[int, tuple[int, bool]] = {
+    0x05: (4, True),  # double-long (int32 signed)
+    0x06: (4, False),  # double-long-unsigned (uint32 unsigned)
+    0x0F: (1, True),  # integer (int8 signed)
+    0x10: (2, True),  # long (int16 signed)
+    0x11: (1, False),  # unsigned (uint8 unsigned)
+    0x12: (2, False),  # long-unsigned (uint16 unsigned)
+    0x14: (8, True),  # long64 (int64 signed)
+    0x15: (8, False),  # long64-unsigned (uint64 unsigned)
+    0x16: (1, False),  # enum (uint8 unsigned)
+}
+
+
+class AxdrReader:
+    """Linear recursive-descent parser for DLMS A-XDR encoded data."""
+
+    def __init__(self, data: bytes) -> None:
+        self._data = data
+        self._position = 0
+
+    @property
+    def remaining(self) -> int:
+        """Number of bytes remaining in the buffer."""
+        return len(self._data) - self._position
+
+    @property
+    def position(self) -> int:
+        """Current parse offset."""
+        return self._position
+
+    def read_byte(self) -> int:
+        """Read a single byte from the buffer."""
+        if self._position >= len(self._data):
+            message = f"Unexpected end of data at offset {self._position}"
+            raise ProtocolError(message)
+        byte = self._data[self._position]
+        self._position += 1
+        return byte
+
+    def read_bytes(self, count: int) -> bytes:
+        """Read exact number of bytes from the buffer."""
+        if count < 0:
+            message = f"Invalid negative byte count: {count}"
+            raise ProtocolError(message)
+        if self._position + count > len(self._data):
+            message = (
+                f"Unexpected end of data: needed {count} bytes at offset {self._position}, "
+                f"only {self.remaining} available"
+            )
+            raise ProtocolError(message)
+        chunk = self._data[self._position : self._position + count]
+        self._position += count
+        return chunk
+
+    def read_length(self) -> int:
+        """Read A-XDR length field supporting single-byte and multi-byte encoding."""
+        initial = self.read_byte()
+        if initial < 0x80:
+            return initial
+        length_bytes_count = initial & 0x7F
+        if length_bytes_count == 0:
+            message = "Indefinite length encoding is not allowed in DLMS A-XDR"
+            raise ProtocolError(message)
+        length_bytes = self.read_bytes(length_bytes_count)
+        return int.from_bytes(length_bytes, "big", signed=False)
+
+    def decode_value(self) -> Any:
+        """Decode the next typed value from the buffer."""
+        tag = self.read_byte()
+
+        # 0x00: null-data
+        if tag == 0x00:
+            return None
+
+        # 0x01: array, 0x02: structure
+        if tag in (0x01, 0x02):
+            count = self.read_length()
+            return [self.decode_value() for _ in range(count)]
+
+        # 0x03: boolean
+        if tag == 0x03:
+            return self.read_byte() != 0
+
+        # 0x04: bit-string
+        if tag == 0x04:
+            bit_count = self.read_length()
+            byte_count = (bit_count + 7) // 8
+            return self.read_bytes(byte_count)
+
+        # 0x09: octet-string, 0x0A: visible-string
+        if tag in (0x09, 0x0A):
+            length = self.read_length()
+            raw = self.read_bytes(length)
+            return raw.decode("utf-8", errors="replace") if tag == 0x0A else raw
+
+        int_spec = _INTEGER_TAG_SPECS.get(tag)
+        if int_spec is not None:
+            byte_length, is_signed = int_spec
+            return int.from_bytes(self.read_bytes(byte_length), "big", signed=is_signed)
+
+        message = f"Unsupported or unknown A-XDR tag 0x{tag:02X} at offset {self._position - 1}"
+        raise ProtocolError(message)
+
+
+def decode_axdr(data: bytes) -> Any:
+    """Convenience helper to decode a single A-XDR value from bytes."""
+    reader = AxdrReader(data)
+    value = reader.decode_value()
+    return value
+
+
+def encode_axdr_length(length: int) -> bytes:
+    """Encode an A-XDR length value."""
+    if length < 0x80:
+        return bytes([length])
+    length_bytes = length.to_bytes((length.bit_length() + 7) // 8, "big")
+    return bytes([0x80 | len(length_bytes)]) + length_bytes

microdlms/client.py

@@ -0,0 +1,299 @@
+"""Asynchronous DLMS meter client powered by serialx."""
+
+from __future__ import annotations
+
+import asyncio
+import contextlib
+from collections.abc import Callable
+from typing import Any, Self
+
+import serialx
+
+from microdlms.exceptions import (
+    AuthenticationError,
+    CommunicationError,
+    DataAccessError,
+)
+from microdlms.obis import CosemAttribute
+from microdlms.session import DlmsSession, SessionState
+from microdlms.types import (
+    AssociatedEvent,
+    AssociationRejectedEvent,
+    ConnectedEvent,
+    DisconnectedEvent,
+    GetAccessErrorEvent,
+    GetResponseEvent,
+    ProtocolErrorEvent,
+    SessionEvent,
+)
+
+
+class AsyncMeterClient:
+    """High-level asynchronous client for reading DLMS/COSEM meters over serial or TCP sockets."""
+
+    def __init__(
+        self,
+        port: str,
+        baudrate: int = 9600,
+        password: str | bytes | None = None,
+        client_logical_address: int = 32,
+        server_logical_address: int = 1,
+        server_physical_address: int | None = None,
+        timeout: float = 10.0,
+        system_title: bytes | None = None,
+        retries: int = 3,
+        retry_delay: float = 0.0,
+    ) -> None:
+        self.port = port
+        self.baudrate = baudrate
+        self.password = password
+        self.client_logical_address = client_logical_address
+        self.server_logical_address = server_logical_address
+        self.server_physical_address = server_physical_address
+        self.timeout = timeout
+        self.system_title = system_title
+        self.retries = retries
+        self.retry_delay = retry_delay
+
+        self._session = DlmsSession(
+            client_address=client_logical_address,
+            server_logical_address=server_logical_address,
+            server_physical_address=server_physical_address,
+            system_title=system_title,
+        )
+        self._reader: asyncio.StreamReader | None = None
+        self._writer: Any = None
+        self._event_queue: list[SessionEvent] = []
+
+    @property
+    def is_connected(self) -> bool:
+        """True if client is connected and application association is active."""
+        return self._session.state == SessionState.ASSOCIATED
+
+    @property
+    def session(self) -> DlmsSession:
+        """Underlying sans-I/O session state machine."""
+        return self._session
+
+    async def connect(self) -> None:
+        """Establish physical serial/socket connection, HDLC link, and DLMS association."""
+        if self._writer is not None:
+            if self.is_connected:
+                return
+            await self.disconnect()
+
+        try:
+            self._reader, self._writer = await serialx.open_serial_connection(
+                url=self.port,
+                baudrate=self.baudrate,
+            )
+        except Exception as error:
+            message = f"Failed to open connection to {self.port}: {error}"
+            raise CommunicationError(message) from error
+
+        try:
+            # Step 1: Establish HDLC physical link (SNRM -> UA)
+            self._session.initiate_connect()
+            await self._flush_outbound()
+            event = await self._wait_for_event(ConnectedEvent, ProtocolErrorEvent)
+            if isinstance(event, ProtocolErrorEvent):
+                message = f"HDLC connect failed: {event.message}"
+                raise CommunicationError(message)
+
+            # Step 2: Establish application association (AARQ -> AARE)
+            self._session.initiate_association(
+                password=self.password, system_title=self.system_title
+            )
+            await self._flush_outbound()
+            event = await self._wait_for_event(
+                AssociatedEvent,
+                AssociationRejectedEvent,
+                ProtocolErrorEvent,
+            )
+            if isinstance(event, AssociationRejectedEvent):
+                message = (
+                    f"Association rejected by meter: result={event.result.name} "
+                    f"(diagnostic={event.diagnostic})"
+                )
+                raise AuthenticationError(message)
+            if isinstance(event, ProtocolErrorEvent):
+                message = f"Association failed: {event.message}"
+                raise CommunicationError(message)
+        except Exception:
+            await self.disconnect()
+            raise
+
+    def _handle_get_response_event(self, event: SessionEvent) -> Any:
+        """Process event received in response to attribute get request."""
+        if isinstance(event, GetResponseEvent):
+            return event.value
+        if isinstance(event, GetAccessErrorEvent):
+            message = f"Meter returned error: {event.error_code.name} ({event.error_code.value})"
+            raise DataAccessError(error_code=event.error_code, message=message)
+        if isinstance(event, ProtocolErrorEvent):
+            message = f"Protocol error during get: {event.message}"
+            raise CommunicationError(message)
+        message = f"Unexpected event received during get: {type(event).__name__}"
+        raise CommunicationError(message)
+
+    async def _execute_get_attempt(
+        self,
+        attribute: CosemAttribute,
+        pending_invoke_ids: set[int],
+        timeout: float | None,
+    ) -> Any:
+        """Send a single attribute request and await its response event."""
+        invoke_id = self._session.request_attribute(attribute)
+        pending_invoke_ids.add(invoke_id)
+        await self._flush_outbound()
+
+        event = await self._wait_for_event(
+            GetResponseEvent,
+            GetAccessErrorEvent,
+            ProtocolErrorEvent,
+            timeout=timeout,
+            predicate=lambda matched_event: (
+                not isinstance(matched_event, (GetResponseEvent, GetAccessErrorEvent))
+                or matched_event.invoke_id in pending_invoke_ids
+            ),
+        )
+        return self._handle_get_response_event(event)
+
+    async def _prepare_next_retry(self, attempt: int, delay: float) -> None:
+        """Wait retry delay and clean transient protocol errors before retrying."""
+        if attempt > 0:
+            if delay > 0:
+                await asyncio.sleep(delay)
+            self._event_queue = [
+                event for event in self._event_queue if not isinstance(event, ProtocolErrorEvent)
+            ]
+
+    def _raise_get_error(
+        self,
+        error: CommunicationError,
+        primary_error: Exception | None,
+        attempt: int,
+        effective_retries: int,
+    ) -> None:
+        """Raise primary or current communication error if disconnected or out of retries."""
+        if not self.is_connected or attempt == effective_retries:
+            final_error = primary_error if primary_error is not None else error
+            raise final_error from error
+
+    async def get(
+        self,
+        attribute: CosemAttribute,
+        retries: int | None = None,
+        retry_delay: float | None = None,
+        timeout: float | None = None,
+    ) -> Any:
+        """Query a COSEM attribute from the meter and return its decoded Python value."""
+        if not self.is_connected:
+            message = "Client is not connected. Call connect() first."
+            raise CommunicationError(message)
+
+        effective_retries = max(0, self.retries if retries is None else retries)
+        effective_delay = self.retry_delay if retry_delay is None else retry_delay
+        primary_error: Exception | None = None
+        pending_invoke_ids: set[int] = set()
+
+        for attempt in range(effective_retries + 1):
+            await self._prepare_next_retry(attempt, effective_delay)
+            try:
+                return await self._execute_get_attempt(attribute, pending_invoke_ids, timeout)
+            except CommunicationError as error:
+                if primary_error is None:
+                    primary_error = error
+                self._raise_get_error(error, primary_error, attempt, effective_retries)
+
+    async def disconnect(self) -> None:
+        """Gracefully release HDLC connection and close serial/socket transport."""
+        try:
+            if self._writer is not None and self._session.state in (
+                SessionState.CONNECTED,
+                SessionState.ASSOCIATED,
+            ):
+                self._session.initiate_disconnect()
+                await self._flush_outbound()
+                with contextlib.suppress(Exception):
+                    await self._wait_for_event(DisconnectedEvent, timeout=min(self.timeout, 2.0))
+        finally:
+            if self._writer is not None:
+                with contextlib.suppress(Exception):
+                    self._writer.close()
+                    await self._writer.wait_closed()
+                self._writer = None
+                self._reader = None
+            self._event_queue.clear()
+
+    async def _flush_outbound(self) -> None:
+        """Transmit any pending bytes from the session outbound buffer."""
+        outbound_bytes = self._session.data_to_send()
+        if outbound_bytes and self._writer is not None:
+            self._writer.write(outbound_bytes)
+            await self._writer.drain()
+
+    def _extract_matching_event(
+        self,
+        expected_types: tuple[type[SessionEvent], ...],
+        predicate: Callable[[SessionEvent], bool] | None,
+    ) -> SessionEvent | None:
+        """Scan event queue for an expected event matching predicate or abort on disconnect."""
+        index = 0
+        while index < len(self._event_queue):
+            event = self._event_queue[index]
+            if isinstance(event, DisconnectedEvent) and DisconnectedEvent not in expected_types:
+                self._event_queue.pop(index)
+                message = "Connection disconnected by meter"
+                raise CommunicationError(message)
+            if isinstance(event, expected_types):
+                if predicate is None or predicate(event):
+                    return self._event_queue.pop(index)
+                self._event_queue.pop(index)
+                continue
+            index += 1
+        return None
+
+    async def _wait_for_event(
+        self,
+        *expected_types: type[SessionEvent],
+        timeout: float | None = None,
+        predicate: Callable[[SessionEvent], bool] | None = None,
+    ) -> SessionEvent:
+        """Read incoming serial bytes until an expected session event arrives."""
+        cached_event = self._extract_matching_event(expected_types, predicate)
+        if cached_event is not None:
+            return cached_event
+
+        if self._reader is None:
+            message = "Reader is not initialized"
+            raise CommunicationError(message)
+
+        effective_timeout = timeout if timeout is not None else self.timeout
+        try:
+            async with asyncio.timeout(effective_timeout):
+                while True:
+                    data = await self._reader.read(1024)
+                    if not data:
+                        message = "Connection closed by peer / EOF encountered"
+                        raise CommunicationError(message)
+
+                    self._event_queue.extend(self._session.receive_bytes(data))
+                    matching = self._extract_matching_event(expected_types, predicate)
+                    if matching is not None:
+                        return matching
+        except TimeoutError as error:
+            message = f"Timeout ({effective_timeout}s) waiting for meter response"
+            raise CommunicationError(message) from error
+
+    async def __aenter__(self) -> Self:
+        await self.connect()
+        return self
+
+    async def __aexit__(
+        self,
+        exception_type: type[BaseException] | None,
+        exception_value: BaseException | None,
+        traceback: Any,
+    ) -> None:
+        await self.disconnect()