aioads 0.1.0.dev5__tar.gz → 0.1.0.dev7__tar.gz

{aioads-0.1.0.dev5 → aioads-0.1.0.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aioads
-Version: 0.1.0.dev5
+Version: 0.1.0.dev7
 Summary: An asynchronous Python library for communicating with Beckhoff TwinCAT PLCs
 Author-email: MkKiefer <102972583+MkKiefer@users.noreply.github.com>
 License: MIT

{aioads-0.1.0.dev5 → aioads-0.1.0.dev7}/aioads/functions/ads_sum_read.py

@@ -5,13 +5,13 @@ sending multiple `AdsReadCommand` in a single command
 https://infosys.beckhoff.com/english.php?content=../content/1033/tc3_adsdll2/124830987.html&id=
 """
 
-
 from struct import Struct
 from typing import Final
 from aioads.ads_error_codes import AdsErrorCode
 from aioads.ams_address import AmsAddress
 from aioads.commands.ads_read import AdsReadCommand, AdsReadResponse
 from aioads.commands.ads_read_write import AdsReadWriteCommand
+from aioads.commands.errors import AdsCommandError
 from aioads.functions.ads_function import AdsFunctionSymbolGroup, IAdsFunction
 from aioads.stream import AdsStream
 from aioads.transport import ITransport
@@ -19,7 +19,7 @@ from aioads.transport import ITransport
 
 class AdsSumRead(IAdsFunction[list[tuple[AdsReadResponse, AdsStream]]]):
     """
-    Ads sum read command that allows batching up to 500 `AdsReadCommand` in a single call    
+    Ads sum read command that allows batching up to 500 `AdsReadCommand` in a single call
     """
 
     ERROR_CODE_STRUCT_DEF: Final[Struct] = Struct("<I")
@@ -36,17 +36,15 @@ class AdsSumRead(IAdsFunction[list[tuple[AdsReadResponse, AdsStream]]]):
 
     def serialize(self) -> bytes:
         """
-        serialize all commands to bytes 
+        serialize all commands to bytes
         """
         return b"".join(command.serialize() for command in self.commands)
 
     async def execute(self) -> list[tuple[AdsReadResponse, AdsStream]]:
         if len(self.commands) == 0:
-            raise ValueError(
-                "At least one command is required for ADS Sum Read")
+            raise ValueError("At least one command is required for ADS Sum Read")
         if len(self.commands) > 500:
-            raise ValueError(
-                "Too many commands for ADS Sum Read, maximum is 500")
+            raise ValueError("Too many commands for ADS Sum Read, maximum is 500")
 
         payload = self.serialize()
         command = AdsReadWriteCommand(
@@ -60,20 +58,27 @@ class AdsSumRead(IAdsFunction[list[tuple[AdsReadResponse, AdsStream]]]):
             write_length=len(payload),
             write_data=payload,
         )
-        _, read_payload = await command.request()
+        header, read_payload = await command.request()
+        if not header.error_code.ok:
+            raise AdsCommandError(header.error_code, "Failed to execute ADS Sum Read")
         error_stream = read_payload.sub_stream(
             # 4 bytes per error code
-            len(self.commands) * self.ERROR_CODE_STRUCT_DEF.size)
+            len(self.commands)
+            * self.ERROR_CODE_STRUCT_DEF.size
+        )
 
         response: list[tuple[AdsReadResponse, AdsStream]] = []
         for cmd in self.commands:
             error_code = AdsErrorCode(
-                error_stream.read_struct(self.ERROR_CODE_STRUCT_DEF)[0])
-            response.append((
-                AdsReadResponse(
-                    error_code=error_code,
-                    length=cmd.length,
-                ),
-                read_payload.sub_stream(cmd.length))
+                error_stream.read_struct(self.ERROR_CODE_STRUCT_DEF)[0]
+            )
+            response.append(
+                (
+                    AdsReadResponse(
+                        error_code=error_code,
+                        length=cmd.length,
+                    ),
+                    read_payload.sub_stream(cmd.length),
+                )
             )
         return response

{aioads-0.1.0.dev5 → aioads-0.1.0.dev7}/aioads/functions/ads_sum_read_write.py

@@ -49,17 +49,17 @@ packet
 ```
 
 """
+
 from aioads.ams_address import AmsAddress
 from aioads.commands.ads_read import AdsReadResponse
 from aioads.commands.ads_read_write import AdsReadWriteCommand
+from aioads.commands.errors import AdsCommandError
 from aioads.functions.ads_function import AdsFunctionSymbolGroup, IAdsFunction
 from aioads.stream import AdsStream
 from aioads.transport import ITransport
 
 
-class AdsSumReadWrite(
-    IAdsFunction[list[tuple[AdsReadResponse, AdsStream]]]
-):
+class AdsSumReadWrite(IAdsFunction[list[tuple[AdsReadResponse, AdsStream]]]):
     """
     ADS Sum Read/Write function to send a READ/WRITE Command in batch.
     This function allows multiple read/write commands to be sent in a single request,
@@ -92,11 +92,9 @@ class AdsSumReadWrite(
         :return: An async generator yielding tuples of (AdsReadResponse, AdsStream) for each command.
         """
         if len(self.commands) == 0:
-            raise ValueError(
-                "At least one command is required for ADS Sum Read/Write")
+            raise ValueError("At least one command is required for ADS Sum Read/Write")
         if len(self.commands) > 500:
-            raise ValueError(
-                "Too many commands for ADS Sum Read/Write, maximum is 500")
+            raise ValueError("Too many commands for ADS Sum Read/Write, maximum is 500")
 
         payload = self.serialize()
         total_read_length = sum(
@@ -117,15 +115,19 @@ class AdsSumReadWrite(
             write_length=total_write_length,
             write_data=payload,
         )
-        _, read_payload = await command.request()
+        header, read_payload = await command.request()
+        if not header.error_code.ok:
+            raise AdsCommandError(
+                header.error_code, "Failed to execute ADS Sum Read/Write"
+            )
         read_response_stream = read_payload.sub_stream(
-            len(self.commands) * AdsReadResponse.STRUCT_DEF.size)
+            len(self.commands) * AdsReadResponse.STRUCT_DEF.size
+        )
 
         response: list[tuple[AdsReadResponse, AdsStream]] = []
         for _ in self.commands:
             read_response = AdsReadResponse.deserialize(read_response_stream)
-            response.append((
-                read_response,
-                read_payload.sub_stream(read_response.length)
-            ))
+            response.append(
+                (read_response, read_payload.sub_stream(read_response.length))
+            )
         return response

{aioads-0.1.0.dev5 → aioads-0.1.0.dev7}/aioads/functions/ads_symbol_datatype_by_name.py

@@ -36,11 +36,13 @@ packet
 
 
 """
+
 from dataclasses import dataclass
 from struct import Struct
 from typing import ClassVar
 from aioads.ams_address import AmsAddress
 from aioads.commands.ads_read_write import AdsReadWriteCommand
+from aioads.commands.errors import AdsCommandError
 from aioads.functions.ads_function import AdsFunctionSymbolGroup, IAdsFunction
 from aioads.functions.ads_symbol_info_by_name_ex import (
     AdsSymbolDataType,
@@ -75,8 +77,7 @@ class AdsDatatypeArrayInfo:
         """
         Create `AdsDatatypeArrayInfo` from the `AdsStream`
         """
-        l_bound, e_elements = data.read_struct(
-            AdsDatatypeArrayInfo.STRUCT_DEF)
+        l_bound, e_elements = data.read_struct(AdsDatatypeArrayInfo.STRUCT_DEF)
         return AdsDatatypeArrayInfo(
             l_bound=l_bound,
             e_elements=e_elements,
@@ -227,6 +228,10 @@ class AdsSymbolDataTypeByName(IAdsFunction[SymbolDataTypeResponse]):
             write_length=len(payload),
             read_length=0xFFFF,  # Max read length
         )
-        _, read_payload = await command.request()
+        header, read_payload = await command.request()
+        if not header.error_code.ok:
+            raise AdsCommandError(
+                header.error_code, "Failed to read symbol datatype by name"
+            )
         symbol_datatype = SymbolDataTypeResponse.deserialize(read_payload)
         return symbol_datatype

{aioads-0.1.0.dev5 → aioads-0.1.0.dev7}/aioads/functions/ads_symbol_datatype_upload.py

@@ -6,6 +6,7 @@ https://infosys.beckhoff.com/english.php?content=../content/1033/tc3_adsdll2/124
 
 from aioads.ams_address import AmsAddress
 from aioads.commands.ads_read import AdsReadCommand
+from aioads.commands.errors import AdsCommandError
 from aioads.functions.ads_function import AdsFunctionSymbolGroup, IAdsFunction
 from aioads.functions.ads_symbol_datatype_by_name import SymbolDataTypeResponse
 from aioads.transport import ITransport
@@ -38,7 +39,9 @@ class AdsSymbolDataTypeUpload(IAdsFunction[list[SymbolDataTypeResponse]]):
             idx_offset=0,
             length=self.dt_size,
         )
-        _, read_payload = await command.request()
+        header, read_payload = await command.request()
+        if not header.error_code.ok:
+            raise AdsCommandError(header.error_code, "Failed to read datatype info")
 
         symbol_datatypes = list[SymbolDataTypeResponse]()
         start = read_payload.tell()

{aioads-0.1.0.dev5 → aioads-0.1.0.dev7}/aioads/functions/ads_symbol_info_by_name_ex.py

@@ -1,5 +1,5 @@
 """
-This module provides models and ads function to get the symbol info (symbol metadata) by the variable / symbol name. 
+This module provides models and ads function to get the symbol info (symbol metadata) by the variable / symbol name.
 """
 
 from dataclasses import dataclass
@@ -9,6 +9,7 @@ from typing import ClassVar
 from aioads.ads_error_codes import AdsErrorCode
 from aioads.ams_address import AmsAddress
 from aioads.commands.ads_read_write import AdsReadWriteCommand
+from aioads.commands.errors import AdsCommandError
 from aioads.functions.ads_function import AdsFunctionSymbolGroup, IAdsFunction
 from aioads.functions.ads_sum_read_write import AdsSumReadWrite
 from aioads.stream import AdsStream
@@ -113,10 +114,8 @@ class SymbolInfo:
             type_name_length,
             comment_length,
         ) = data.read_struct(SymbolInfo.FIXED_STRUCT)
-        symbol_name = data.read(symbol_name_length + 1).rstrip(
-            b"\x00").decode("cp1252")
-        type_name = data.read(type_name_length + 1).rstrip(
-            b"\x00").decode("cp1252")
+        symbol_name = data.read(symbol_name_length + 1).rstrip(b"\x00").decode("cp1252")
+        type_name = data.read(type_name_length + 1).rstrip(b"\x00").decode("cp1252")
         comment = data.read(comment_length + 1).rstrip(b"\x00").decode("cp1252")
 
         # Move the stream position to the end of the entry
@@ -133,6 +132,20 @@ class SymbolInfo:
             comment=comment,
         )
 
+    @classmethod
+    def void(cls) -> "SymbolInfo":
+        """A void symbol info that can be used as a placeholder"""
+        return cls(
+            idx_group=0,
+            idx_offset=0,
+            idx_length=0,
+            data_type=AdsSymbolDataType.VOID,
+            symbol_flags=AdsSymbolFlags(0),
+            symbol_name="",
+            type_name="",
+            comment="",
+        )
+
 
 class SymbolInfoByNameEx(IAdsFunction[SymbolInfo]):
     """
@@ -165,14 +178,14 @@ class SymbolInfoByNameEx(IAdsFunction[SymbolInfo]):
             read_length=0xFFFF,  # Max read length
             write_data=payload,
         )
-        _, read_payload = await command.request()
+        header, read_payload = await command.request()
+        if not header.error_code.ok:
+            raise AdsCommandError(header.error_code, "Failed to read symbol info")
         symbol_info = SymbolInfo.deserialize(read_payload)
         return symbol_info
 
 
-class SymbolInfoByNameExSumRead(
-    IAdsFunction[list[tuple[AdsErrorCode, SymbolInfo]]]
-):
+class SymbolInfoByNameExSumRead(IAdsFunction[list[tuple[AdsErrorCode, SymbolInfo]]]):
     """
     This function utilizes the `AdsSumReadWrite` function to
     send multiple `SymbolInfoByNameEx` function calls in a batch.
@@ -219,9 +232,14 @@ class SymbolInfoByNameExSumRead(
             command = AdsSumReadWrite(
                 transport=self.transport,
                 ams_address=self.ams_address,
-                commands=commands[batch_start:batch_start + self.BATCH_SIZE],
+                commands=commands[batch_start : batch_start + self.BATCH_SIZE],
             )
-            for read_header, read_payload in await command.execute():
+            for header, read_payload in await command.execute():
+                # If we have an error and no payload we return a void symbol info
+                # we raise no exception to let the client handle the error for each symbol individually
+                if not header.error_code.ok and read_payload.length == 0:
+                    response.append((header.error_code, SymbolInfo.void()))
+                    continue
                 symbol_info = SymbolInfo.deserialize(read_payload)
-                response.append((read_header.error_code, symbol_info))
+                response.append((header.error_code, symbol_info))
         return response

{aioads-0.1.0.dev5 → aioads-0.1.0.dev7}/aioads/functions/ads_symbol_table_version.py

@@ -2,7 +2,7 @@
 This module contains the ads function call for requesting the `SymbolTableVersion`.
 
 
-This can be used to monitoring, on change the index offsets in symbol metadata can change 
+This can be used to monitoring, on change the index offsets in symbol metadata can change
 and we need to re resolve the new address where we can read this symbol, if we don't do this
 we read a random memory array we most likely can't parse.
 https://infosys.beckhoff.com/english.php?content=../content/1033/tc3_adsdll2/124830987.html&id=
@@ -42,8 +42,9 @@ class SymbolTableVersion(IAdsFunction[int]):
             idx_offset=0,
             length=1,
         )
-        read_resp, read_stream = await command.request()
-        if not read_resp.error_code.ok:
-            raise AdsCommandError(read_resp.error_code,
-                                  "Failed to read symbol table version")
+        header, read_stream = await command.request()
+        if not header.error_code.ok:
+            raise AdsCommandError(
+                header.error_code, "Failed to read symbol table version"
+            )
         return read_stream.read_struct(self.VERSION_STRUCT_DEF)[0]

{aioads-0.1.0.dev5 → aioads-0.1.0.dev7}/aioads/functions/ads_symbol_upload.py

@@ -1,9 +1,10 @@
 """
-This module contains a ads function to acquire the symbol infos (metadata) of the global / root symbols.  
+This module contains a ads function to acquire the symbol infos (metadata) of the global / root symbols.
 """
 
 from aioads.ams_address import AmsAddress
 from aioads.commands.ads_read import AdsReadCommand
+from aioads.commands.errors import AdsCommandError
 from aioads.functions.ads_function import AdsFunctionSymbolGroup, IAdsFunction
 from aioads.functions.ads_symbol_info_by_name_ex import SymbolInfo
 from aioads.transport import ITransport
@@ -11,8 +12,8 @@ from aioads.transport import ITransport
 
 class AdsSymbolUpload(IAdsFunction[list[SymbolInfo]]):
     """
-    Ads Function to read all global symbols. 
-    Hint: 
+    Ads Function to read all global symbols.
+    Hint:
         Only the top most symbol information are returned, to get the full ads tree
         you need to resolve it from this over the datatypes that can be requested with `AdsSymbolDataTypeUpload`
     """
@@ -36,7 +37,12 @@ class AdsSymbolUpload(IAdsFunction[list[SymbolInfo]]):
             idx_offset=0,
             length=self.tree_size,
         )
-        _, read_payload = await command.request()
+        header, read_payload = await command.request()
+        if not header.error_code.ok:
+            raise AdsCommandError(
+                header.error_code, "Failed to request symbol upload info"
+            )
+
         symbol_infos = list[SymbolInfo]()
 
         start = read_payload.tell()

{aioads-0.1.0.dev5 → aioads-0.1.0.dev7}/aioads/functions/ads_symbol_upload_info.py

@@ -10,6 +10,7 @@ from typing import ClassVar
 
 from aioads.ams_address import AmsAddress
 from aioads.commands.ads_read import AdsReadCommand
+from aioads.commands.errors import AdsCommandError
 from aioads.functions.ads_function import AdsFunctionSymbolGroup, IAdsFunction
 
 from aioads.stream import AdsStream
@@ -46,11 +47,9 @@ class SymbolUploadInfo2Response:
     @classmethod
     def deserialize(cls, data: AdsStream) -> "SymbolUploadInfo2Response":
         """
-        Create `SymbolUploadInfo2Response` from the `AdsStream` 
+        Create `SymbolUploadInfo2Response` from the `AdsStream`
         """
-        parsed: tuple[
-            int, int, int, int, int, int
-        ] = data.read_struct(cls.STRUCT_DEF)
+        parsed: tuple[int, int, int, int, int, int] = data.read_struct(cls.STRUCT_DEF)
         return cls(
             symbol_cnt=parsed[0],
             symbol_size=parsed[1],
@@ -63,7 +62,7 @@ class SymbolUploadInfo2Response:
 
 class AdsSymbolUploadInfo2(IAdsFunction[SymbolUploadInfo2Response]):
     """
-    Function to acquire basic symbol information 
+    Function to acquire basic symbol information
     """
 
     def __init__(self, transport: ITransport, ams_address: AmsAddress) -> None:
@@ -83,7 +82,10 @@ class AdsSymbolUploadInfo2(IAdsFunction[SymbolUploadInfo2Response]):
             # 6 x 4 bytes (We expect a struct with 6x UINT32)
             length=SymbolUploadInfo2Response.STRUCT_DEF.size,
         )
-        _, read_payload = await command.request()
-        symbol_upload_info = SymbolUploadInfo2Response.deserialize(
-            read_payload)
+        header, read_payload = await command.request()
+        if not header.error_code.ok:
+            raise AdsCommandError(
+                header.error_code, "Failed to request symbol upload info"
+            )
+        symbol_upload_info = SymbolUploadInfo2Response.deserialize(read_payload)
         return symbol_upload_info

{aioads-0.1.0.dev5 → aioads-0.1.0.dev7}/aioads/transport.py

@@ -7,6 +7,7 @@ import enum
 import logging
 import random
 import re
+import socket
 from abc import ABC
 from dataclasses import dataclass
 from dataclasses import field
@@ -211,6 +212,22 @@ class AdsTcpTransport(BaseTransport, ITransport):
     RECONNECT_INITIAL_BACKOFF = 1.0
     RECONNECT_MAX_BACKOFF = 30.0
 
+    # TCP keepalive / liveness tuning.
+    # Without these, a half-open connection (peer power-cut, cable pull, NAT
+    # idle-eviction) is never detected: no FIN/RST arrives, so the read loop
+    # blocks forever and the supervisor never reconnects. These force the kernel
+    # to probe an idle peer and to bound how long unacked writes wait, so a dead
+    # link surfaces as a socket error within ~KEEPALIVE_IDLE + KEEPALIVE_INTERVAL
+    # * KEEPALIVE_COUNT seconds.
+    KEEPALIVE_IDLE = 10
+    """Seconds of idle before the kernel starts sending keepalive probes (Linux: TCP_KEEPIDLE)."""
+    KEEPALIVE_INTERVAL = 3
+    """Seconds between keepalive probes (Linux: TCP_KEEPINTVL)."""
+    KEEPALIVE_COUNT = 3
+    """Unanswered probes before the connection is considered dead (Linux: TCP_KEEPCNT)."""
+    USER_TIMEOUT_MS = 15_000
+    """Milliseconds an unacked write may wait before the socket errors (Linux: TCP_USER_TIMEOUT)."""
+
     def __init__(
         self,
         src_address: AmsAddress,
@@ -279,10 +296,43 @@ class AdsTcpTransport(BaseTransport, ITransport):
         reader, writer = await asyncio.wait_for(
             asyncio.open_connection(self.ip, self.port), self.CONNECT_TIMEOUT
         )
+
+        self._enable_keepalive(writer)
         async with self._stream_lock:
             self._stream = (reader, writer)
         self._state = ConnectionState.CONNECTED
 
+    def _enable_keepalive(self, writer: asyncio.StreamWriter) -> None:
+        """
+        Enable TCP keepalive so a half-open connection is detected 
+        even when no FIN/RST is ever sent.
+
+        The per-option settings beyond SO_KEEPALIVE are platform specific; each
+        is applied only when the running platform exposes it, so this stays a
+        no-op on systems that lack the knob rather than raising.
+        """
+
+        sock: socket.socket | None = writer.get_extra_info("socket")
+        if sock is None:
+            self.logger.warning(
+                "Failed to enable TCP keepalive: StreamWriter has no socket"
+            )
+            return
+
+        try:
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
+            for opt_name, value in (
+                ("TCP_KEEPIDLE", self.KEEPALIVE_IDLE),
+                ("TCP_KEEPINTVL", self.KEEPALIVE_INTERVAL),
+                ("TCP_KEEPCNT", self.KEEPALIVE_COUNT),
+                ("TCP_USER_TIMEOUT", self.USER_TIMEOUT_MS),
+            ):
+                opt = getattr(socket, opt_name, None)
+                if opt is not None:
+                    sock.setsockopt(socket.IPPROTO_TCP, opt, value)
+        except OSError as e:
+            self.logger.warning("Failed to enable TCP keepalive: %s", e)
+
     async def _teardown_stream(self, ex: BaseException):
         """
         Fail all in-flight requests and close the current stream (if any).
@@ -364,7 +414,7 @@ class AdsTcpTransport(BaseTransport, ITransport):
         while self._state is not ConnectionState.CLOSED:
             try:
                 await self._read_loop()
-            except asyncio.CancelledError: #pylint: disable=try-except-raise
+            except asyncio.CancelledError:  # pylint: disable=try-except-raise
                 # Except everything... except a cancellation event
                 raise
             except Exception as e:
@@ -382,7 +432,7 @@ class AdsTcpTransport(BaseTransport, ITransport):
                     self.logger.info("Reconnected to the remote")
                     backoff = self.RECONNECT_INITIAL_BACKOFF
                     break
-                except asyncio.CancelledError: #pylint: disable=try-except-raise
+                except asyncio.CancelledError:  # pylint: disable=try-except-raise
                     raise
                 except Exception as e:  # pylint: disable=broad-exception-caught
                     self.logger.info(

{aioads-0.1.0.dev5 → aioads-0.1.0.dev7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aioads"
-version = "0.1.0.dev5"
+version = "0.1.0.dev7"
 description = "An asynchronous Python library for communicating with Beckhoff TwinCAT PLCs"
 authors = [
     { name = "MkKiefer", email = "102972583+MkKiefer@users.noreply.github.com" },

{aioads-0.1.0.dev5 → aioads-0.1.0.dev7}/tests/unit/test_transport.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import logging
+import socket
 import unittest
 from unittest.mock import Mock
 
@@ -216,5 +217,73 @@ class TestAdsTcpTransport(unittest.IsolatedAsyncioTestCase):
         self.assertIsInstance(ctx.exception.__cause__, asyncio.IncompleteReadError)
 
 
+class TestAdsTcpTransportKeepalive(unittest.TestCase):
+    """TCP keepalive / liveness configuration applied to the active socket."""
+
+    def setUp(self) -> None:
+        self.transport = AdsTcpTransport(
+            src_address=make_ams_address(), ip="127.0.0.1"
+        )
+        # A real AF_INET TCP socket whose options we can read back. It does not
+        # need to be connected to accept these socket options.
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.addCleanup(self.sock.close)
+        # A StreamWriter exposes its underlying socket via get_extra_info("socket").
+        self.writer = Mock()
+        self.writer.get_extra_info.return_value = self.sock
+
+    def test_enable_keepalive_turns_on_so_keepalive(self) -> None:
+        # Act
+        self.transport._enable_keepalive(self.writer)
+
+        # Assert
+        self.assertEqual(
+            self.sock.getsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE), 1
+        )
+
+    @unittest.skipUnless(
+        hasattr(socket, "TCP_KEEPIDLE"), "platform lacks TCP keepalive tuning"
+    )
+    def test_enable_keepalive_applies_configured_tuning_values(self) -> None:
+        # Act
+        self.transport._enable_keepalive(self.writer)
+
+        # Assert — each kernel knob reflects the transport's configured constant
+        expected = [
+            ("TCP_KEEPIDLE", AdsTcpTransport.KEEPALIVE_IDLE),
+            ("TCP_KEEPINTVL", AdsTcpTransport.KEEPALIVE_INTERVAL),
+            ("TCP_KEEPCNT", AdsTcpTransport.KEEPALIVE_COUNT),
+            ("TCP_USER_TIMEOUT", AdsTcpTransport.USER_TIMEOUT_MS),
+        ]
+        for opt_name, value in expected:
+            opt = getattr(socket, opt_name, None)
+            if opt is None:
+                continue
+            with self.subTest(option=opt_name):
+                self.assertEqual(
+                    self.sock.getsockopt(socket.IPPROTO_TCP, opt), value
+                )
+
+    def test_enable_keepalive_without_socket_does_not_raise(self) -> None:
+        # Arrange — a StreamWriter without an underlying socket
+        self.writer.get_extra_info.return_value = None
+
+        # Act / Assert — keepalive is best-effort, so it is skipped quietly
+        try:
+            self.transport._enable_keepalive(self.writer)
+        except Exception as e:  # pragma: no cover - failure path
+            self.fail(f"_enable_keepalive must not raise when no socket: {e}")
+
+    def test_enable_keepalive_on_closed_socket_does_not_raise(self) -> None:
+        # Arrange — a closed socket makes setsockopt fail with OSError
+        self.sock.close()
+
+        # Act / Assert — keepalive is best-effort, so the error is swallowed
+        try:
+            self.transport._enable_keepalive(self.writer)
+        except OSError:
+            self.fail("_enable_keepalive must not propagate socket errors")
+
+
 if __name__ == "__main__":
     unittest.main()