python-snap7 3.1.0__tar.gz → 3.1.1__tar.gz

{python_snap7-3.1.0/python_snap7.egg-info → python_snap7-3.1.1}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: python-snap7
-Version: 3.1.0
+Version: 3.1.1
 Summary: Pure Python S7 communication library for Siemens PLCs
 Author-email: Gijs Molenaar <gijsmolenaar@gmail.com>
-License: MIT
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/gijzelaerr/python-snap7
 Project-URL: Documentation, https://python-snap7.readthedocs.io/en/latest/
 Keywords: snap7,s7,siemens,plc

{python_snap7-3.1.0 → python_snap7-3.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-snap7"
-version = "3.1.0"
+version = "3.1.1"
 description = "Pure Python S7 communication library for Siemens PLCs"
 readme = "README.rst"
 authors = [
@@ -23,7 +23,7 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
     "Programming Language :: Python :: 3.14",
 ]
-license = {text = "MIT"}
+license = "MIT"
 requires-python = ">=3.10"
 keywords = ["snap7", "s7", "siemens", "plc"]
 

{python_snap7-3.1.0 → python_snap7-3.1.1/python_snap7.egg-info}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: python-snap7
-Version: 3.1.0
+Version: 3.1.1
 Summary: Pure Python S7 communication library for Siemens PLCs
 Author-email: Gijs Molenaar <gijsmolenaar@gmail.com>
-License: MIT
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/gijzelaerr/python-snap7
 Project-URL: Documentation, https://python-snap7.readthedocs.io/en/latest/
 Keywords: snap7,s7,siemens,plc

{python_snap7-3.1.0 → python_snap7-3.1.1}/snap7/async_client.py

@@ -389,7 +389,7 @@ class AsyncClient(ClientMixin):
         self.slot = slot
         self._params[Parameter.RemotePort] = tcp_port
 
-        self.remote_tsap = 0x0100 | (rack << 5) | slot
+        self.remote_tsap = (self.connection_type << 8) | (rack << 5) | slot
 
         try:
             start_time = time.time()
@@ -1159,7 +1159,11 @@ class AsyncClient(ClientMixin):
         if response.get("parameters"):
             params = response["parameters"]
             if "pdu_length" in params:
-                self.pdu_length = params["pdu_length"]
+                negotiated = params["pdu_length"]
+                if negotiated < 64:
+                    logger.warning(f"Server negotiated implausible PDU length {negotiated}, using minimum 240")
+                    negotiated = 240
+                self.pdu_length = negotiated
                 self._params[Parameter.PDURequest] = self.pdu_length
                 logger.info(f"Negotiated PDU length: {self.pdu_length}")
 

{python_snap7-3.1.0 → python_snap7-3.1.1}/snap7/client.py

@@ -52,7 +52,7 @@ _VALID_AREA_VALUES: frozenset[int] = frozenset(a.value for a in Area)
 logger = logging.getLogger(__name__)
 
 
-def _decode_tag(tag: Tag, data: bytearray) -> Any:
+def _decode_tag(tag: Tag, data: bytearray, encoding: str = "latin-1") -> Any:
     """Decode a Tag's raw bytes into a typed Python value."""
     upper = tag.datatype.upper()
     # Variable-length string types
@@ -60,9 +60,9 @@ def _decode_tag(tag: Tag, data: bytearray) -> Any:
     if match:
         kind, length = match.group(1), int(match.group(2))
         if kind == "FSTRING":
-            return util.get_fstring(data, 0, length)
+            return util.get_fstring(data, 0, length, encoding=encoding)
         if kind == "STRING":
-            return util.get_string(data, 0)
+            return util.get_string(data, 0, encoding=encoding)
         if kind == "WSTRING":
             return util.get_wstring(data, 0)
 
@@ -129,17 +129,17 @@ def _decode_scalar(datatype: str, data: bytearray, bit: int) -> Any:
     raise ValueError(f"Unsupported tag datatype: {datatype}")
 
 
-def _encode_tag(tag: Tag, buf: bytearray, value: Any) -> None:
+def _encode_tag(tag: Tag, buf: bytearray, value: Any, encoding: str = "latin-1") -> None:
     """Encode a typed Python value into a Tag's byte buffer."""
     upper = tag.datatype.upper()
     match = _STRING_RE.match(upper)
     if match:
         kind, length = match.group(1), int(match.group(2))
         if kind == "FSTRING":
-            util.set_fstring(buf, 0, value, length)
+            util.set_fstring(buf, 0, value, length, encoding=encoding)
             return
         if kind == "STRING":
-            util.set_string(buf, 0, value, length)
+            util.set_string(buf, 0, value, length, encoding=encoding)
             return
         if kind == "WSTRING":
             util.set_wstring(buf, 0, value, length)
@@ -656,7 +656,7 @@ class Client(ClientMixin):
         self._params[Parameter.RemotePort] = port
 
         # Remote TSAP targets the gateway rack/slot
-        self.remote_tsap = 0x0100 | (router_rack << 5) | router_slot
+        self.remote_tsap = (self.connection_type << 8) | (router_rack << 5) | router_slot
 
         try:
             start_time = time.time()
@@ -780,7 +780,7 @@ class Client(ClientMixin):
             struct.pack_into(fmt, data, i * item_size, v)
         return self.db_write(db_number, start, data)
 
-    def read_tag(self, tag: "Union[Tag, str]") -> Any:
+    def read_tag(self, tag: "Union[Tag, str]", encoding: str = "latin-1") -> Any:
         """Read a typed value by :class:`~snap7.tags.Tag` or address string.
 
         Accepts a :class:`~snap7.tags.Tag` or a PLC4X-style address string
@@ -788,6 +788,8 @@ class Client(ClientMixin):
 
         Args:
             tag: A :class:`~snap7.tags.Tag` instance or a parseable address string.
+            encoding: Character encoding for STRING/FSTRING values (default ``"latin-1"``).
+                Use ``"gbk"`` for Chinese PLCs or ``"utf-8"`` for UTF-8 encoded strings.
 
         Returns:
             The typed value (bool/int/float/datetime/str depending on type).
@@ -798,6 +800,7 @@ class Client(ClientMixin):
             client.read_tag("DB1.DBD4:REAL")              # float
             client.read_tag("DB1:20:STRING[30]")          # variable-length string
             client.read_tag(Tag(Area.DB, 1, 0, "REAL"))   # from Tag instance
+            client.read_tag("DB1:34:STRING[10]", encoding="gbk")  # Chinese string
         """
         resolved = Tag.from_string(tag) if isinstance(tag, str) else tag
         if resolved.is_symbolic:
@@ -805,14 +808,15 @@ class Client(ClientMixin):
                 "Symbolic (LID-based) tag access requires S7CommPlus. Use s7.Client instead of snap7.Client."
             )
         data = self.read_area(Area(resolved.area), resolved.db_number, resolved.byte_offset, resolved.size)
-        return _decode_tag(resolved, bytearray(data))
+        return _decode_tag(resolved, bytearray(data), encoding=encoding)
 
-    def write_tag(self, tag: "Union[Tag, str]", value: Any) -> int:
+    def write_tag(self, tag: "Union[Tag, str]", value: Any, encoding: str = "latin-1") -> int:
         """Write a typed value by :class:`~snap7.tags.Tag` or address string.
 
         Args:
             tag: A :class:`~snap7.tags.Tag` instance or a parseable address string.
             value: The value to write (type must match the tag's datatype).
+            encoding: Character encoding for STRING/FSTRING values (default ``"latin-1"``).
 
         Returns:
             0 on success.
@@ -828,10 +832,10 @@ class Client(ClientMixin):
         if resolved.datatype.upper() == "BOOL":
             current = self.read_area(Area(resolved.area), resolved.db_number, resolved.byte_offset, 1)
             buf[0] = current[0]
-        _encode_tag(resolved, buf, value)
+        _encode_tag(resolved, buf, value, encoding=encoding)
         return self.write_area(Area(resolved.area), resolved.db_number, resolved.byte_offset, buf)
 
-    def read_tags(self, tags: "list[Union[Tag, str]]") -> list[Any]:
+    def read_tags(self, tags: "list[Union[Tag, str]]", encoding: str = "latin-1") -> list[Any]:
         """Read multiple tags in a single optimized request.
 
         Uses the multi-variable read optimizer when available to batch
@@ -839,6 +843,7 @@ class Client(ClientMixin):
 
         Args:
             tags: List of :class:`~snap7.tags.Tag` instances or address strings.
+            encoding: Character encoding for STRING/FSTRING values (default ``"latin-1"``).
 
         Returns:
             List of decoded values in the same order as input.
@@ -846,7 +851,7 @@ class Client(ClientMixin):
         resolved = [Tag.from_string(t) if isinstance(t, str) else t for t in tags]
         items = [{"area": Area(t.area), "db_number": t.db_number, "start": t.byte_offset, "size": t.size} for t in resolved]
         _code, data_list = self.read_multi_vars(items)
-        return [_decode_tag(t, bytearray(d)) for t, d in zip(resolved, data_list)]
+        return [_decode_tag(t, bytearray(d), encoding=encoding) for t, d in zip(resolved, data_list)]
 
     def db_read(self, db_number: int, start: int, size: int) -> bytearray:
         """
@@ -1289,8 +1294,13 @@ class Client(ClientMixin):
 
     def _execute_packets_sequential(self, packet_requests: list[Tuple[int, bytes, ReadPacket]]) -> None:
         """Execute multi-block packets one at a time."""
-        for _, request, packet in packet_requests:
-            response = self._send_receive(request)
+        for _, _request, packet in packet_requests:
+            block_specs = [(blk.area, blk.db_number, blk.start_offset, blk.byte_length) for blk in packet.blocks]
+
+            def build_request(specs: list[tuple[int, int, int, int]] = block_specs) -> bytes:
+                return self.protocol.build_multi_read_request(specs)
+
+            response = self._send_receive_with_reconnect(build_request)
             block_data_list = self.protocol.extract_multi_read_data(response, len(packet.blocks))
             for blk, buf in zip(packet.blocks, block_data_list):
                 blk.buffer = buf
@@ -1299,9 +1309,20 @@ class Client(ClientMixin):
         """Execute multi-block packets using parallel dispatch.
 
         Sends up to *max_parallel* PDUs back-to-back before reading
-        responses, reducing round-trip overhead.
+        responses, reducing round-trip overhead.  Falls back to
+        sequential reconnect-aware execution on connection loss.
         """
-        # Process in chunks of max_parallel
+        try:
+            self._execute_packets_parallel_inner(packet_requests)
+        except (S7ConnectionError, OSError) as e:
+            if not self._auto_reconnect:
+                raise
+            logger.warning(f"Connection lost during parallel read: {e}")
+            self._do_reconnect()
+            self._execute_packets_sequential(packet_requests)
+
+    def _execute_packets_parallel_inner(self, packet_requests: list[Tuple[int, bytes, ReadPacket]]) -> None:
+        """Inner parallel dispatch without reconnect handling."""
         for chunk_start in range(0, len(packet_requests), self.max_parallel):
             chunk = packet_requests[chunk_start : chunk_start + self.max_parallel]
             requests = [(pkt_idx, pdu) for pkt_idx, pdu, _ in chunk]
@@ -2641,7 +2662,11 @@ class Client(ClientMixin):
         if response.get("parameters"):
             params = response["parameters"]
             if "pdu_length" in params:
-                self.pdu_length = params["pdu_length"]
+                negotiated = params["pdu_length"]
+                if negotiated < 64:
+                    logger.warning(f"Server negotiated implausible PDU length {negotiated}, using minimum 240")
+                    negotiated = 240
+                self.pdu_length = negotiated
                 self._params[Parameter.PDURequest] = self.pdu_length
                 logger.info(f"Negotiated PDU length: {self.pdu_length}")
 

{python_snap7-3.1.0 → python_snap7-3.1.1}/snap7/client_base.py

@@ -224,16 +224,22 @@ class ClientMixin:
 
         Calculated as PDU length minus overhead:
         12 bytes S7 header + 2 bytes param + 4 bytes data header = 18 bytes.
+
+        Returns at least 1 to prevent infinite loops in chunked reads
+        when the server negotiates an implausibly small PDU.
         """
-        return self.pdu_length - 18
+        return max(1, self.pdu_length - 18)
 
     def _max_write_size(self) -> int:
         """Maximum payload bytes for a single write request.
 
         Calculated as PDU length minus overhead:
         12 bytes S7 header + 14 bytes param + 4 bytes data header + 5 bytes padding = 35 bytes.
+
+        Returns at least 1 to prevent infinite loops in chunked writes
+        when the server negotiates an implausibly small PDU.
         """
-        return self.pdu_length - 35
+        return max(1, self.pdu_length - 35)
 
     def _map_area(self, area: Area) -> S7Area:
         """Map library area enum to native S7 area."""

{python_snap7-3.1.0 → python_snap7-3.1.1}/snap7/connection.py

@@ -371,11 +371,19 @@ class ISOTCPConnection:
             if param_code == self.COTP_PARAM_PDU_SIZE:
                 # PDU Size parameter
                 if param_len == 1:
-                    # ISO 8073 code: size = 2^code
-                    self.pdu_size = 1 << param_data[0]
+                    # ISO 8073 code: size = 2^code, valid range 7-13
+                    exponent = param_data[0]
+                    if 7 <= exponent <= 13:
+                        self.pdu_size = 1 << exponent
+                    else:
+                        logger.warning(f"Invalid COTP PDU size exponent {exponent}, using default")
                 elif param_len == 2:
                     # Raw 2-byte value
-                    self.pdu_size = struct.unpack(">H", param_data)[0]
+                    raw = struct.unpack(">H", param_data)[0]
+                    if 128 <= raw <= 8192:
+                        self.pdu_size = raw
+                    else:
+                        logger.warning(f"Invalid COTP PDU size {raw}, using default")
                 logger.debug(f"Negotiated PDU size: {self.pdu_size}")
             else:
                 logger.debug(f"Unsupported COTP parameter: code={param_code:#04x}, length={param_len}")

{python_snap7-3.1.0 → python_snap7-3.1.1}/snap7/server/__init__.py

@@ -816,9 +816,9 @@ class Server:
             word_len = addr.get("word_len", S7WordLen.BYTE)
 
             # Convert count to bytes
-            if word_len in (S7WordLen.TIMER, S7WordLen.COUNTER, S7WordLen.WORD):
+            if word_len in (S7WordLen.TIMER, S7WordLen.COUNTER, S7WordLen.WORD, S7WordLen.INT):
                 byte_count = count * 2
-            elif word_len in (S7WordLen.DWORD, S7WordLen.REAL):
+            elif word_len in (S7WordLen.DWORD, S7WordLen.REAL, S7WordLen.DINT):
                 byte_count = count * 4
             elif word_len == S7WordLen.BIT:
                 byte_count = 1
@@ -876,9 +876,9 @@ class Server:
                 word_len = addr_spec.get("word_len", S7WordLen.BYTE)
 
                 # Convert count to bytes based on word length
-                if word_len in [S7WordLen.TIMER, S7WordLen.COUNTER, S7WordLen.WORD]:
+                if word_len in [S7WordLen.TIMER, S7WordLen.COUNTER, S7WordLen.WORD, S7WordLen.INT]:
                     byte_count = count * 2  # 16-bit items
-                elif word_len in [S7WordLen.DWORD, S7WordLen.REAL]:
+                elif word_len in [S7WordLen.DWORD, S7WordLen.REAL, S7WordLen.DINT]:
                     byte_count = count * 4  # 32-bit items
                 elif word_len == S7WordLen.BIT:
                     byte_count = 1  # Single bit needs at least 1 byte
@@ -2418,7 +2418,9 @@ class Server:
             block_num = ctx["block_num"]
             block_data = ctx["data"]
 
-            # Store block data
+            # Store block data — only into pre-registered areas.
+            # Reject downloads to unknown areas to prevent unbounded memory
+            # allocation from attacker-controlled block numbers.
             if block_type == 0x41:  # DB
                 area_key = (S7Area.DB, block_num)
                 if area_key in self.memory_areas:
@@ -2428,9 +2430,9 @@ class Server:
                         copy_len = min(len(block_data), len(existing_area))
                         existing_area[0:copy_len] = block_data[0:copy_len]
                 else:
-                    # Create new area
-                    self.memory_areas[area_key] = bytearray(block_data)
-                    self.area_locks[area_key] = threading.Lock()
+                    logger.warning(f"Download rejected: area DB{block_num} not registered")
+                    del self._download_contexts[client_address]
+                    return self._build_error_response(request, 0x8104)
 
             logger.info(f"Download ended from {client_address}: stored {len(block_data)} bytes to {block_type:#02x}:{block_num}")
 
@@ -2493,6 +2495,9 @@ class ServerISOConnection:
     COTP_DC = 0xC0  # Disconnect Confirm
     COTP_DT = 0xF0  # Data Transfer
 
+    # COTP parameter code for TPDU size (ISO 8073)
+    COTP_PARAM_PDU_SIZE = 0xC0
+
     def __init__(self, client_socket: socket.socket):
         """Initialize server ISO connection."""
         self.socket = client_socket
@@ -2500,6 +2505,7 @@ class ServerISOConnection:
         self.connected = False
         self.src_ref = 0x0001  # Server reference
         self.dst_ref = 0x0000  # Client reference (assigned during handshake)
+        self.tpdu_size = 0x0A  # Default: 1024 bytes (2^10)
 
     def accept_connection(self) -> bool:
         """Accept ISO connection from client."""
@@ -2532,25 +2538,40 @@ class ServerISOConnection:
             return False
 
     def receive_data(self) -> bytes:
-        """Receive data from client."""
-        # Receive TPKT header (4 bytes)
-        tpkt_header = self._recv_exact(4)
+        """Receive data from client.
+
+        Reassembles COTP DT fragments by reading frames until the EOT
+        bit (bit 7 of the third COTP header byte) is set, then returns
+        the concatenated payload.
+        """
+        fragments: list[bytes] = []
+        while True:
+            tpkt_header = self._recv_exact(4)
+            version, reserved, length = struct.unpack(">BBH", tpkt_header)
+
+            if version != 3:
+                raise S7ConnectionError(f"Invalid TPKT version: {version}")
+
+            remaining = length - 4
+            if remaining <= 0:
+                raise S7ConnectionError("Invalid TPKT length")
 
-        # Parse TPKT header
-        version, reserved, length = struct.unpack(">BBH", tpkt_header)
+            payload = self._recv_exact(remaining)
 
-        if version != 3:
-            raise S7ConnectionError(f"Invalid TPKT version: {version}")
+            if len(payload) < 3:
+                raise S7ConnectionError("Invalid COTP DT: too short")
 
-        # Receive remaining data
-        remaining = length - 4
-        if remaining <= 0:
-            raise S7ConnectionError("Invalid TPKT length")
+            pdu_len, pdu_type, eot_num = struct.unpack(">BBB", payload[:3])
 
-        payload = self._recv_exact(remaining)
+            if pdu_type != self.COTP_DT:
+                raise S7ConnectionError(f"Expected COTP DT, got {pdu_type:#02x}")
 
-        # Parse COTP header and extract data
-        return self._parse_cotp_data(payload)
+            fragments.append(payload[3:])
+
+            if eot_num & 0x80:
+                break
+
+        return b"".join(fragments)
 
     def send_data(self, data: bytes) -> None:
         """Send data to client."""
@@ -2578,22 +2599,43 @@ class ServerISOConnection:
         # Store client reference
         self.dst_ref = src_ref
 
+        # Parse variable parameters for TPDU size
+        offset = 7
+        while offset + 2 <= len(data):
+            param_code = data[offset]
+            param_len = data[offset + 1]
+            if offset + 2 + param_len > len(data):
+                break
+            if param_code == self.COTP_PARAM_PDU_SIZE and param_len == 1:
+                exponent = data[offset + 2]
+                if 7 <= exponent <= 13:
+                    self.tpdu_size = exponent
+                    logger.debug(f"Client requested TPDU size 2^{exponent} = {1 << exponent}")
+            offset += 2 + param_len
+
         logger.debug(f"Received COTP CR from client ref {src_ref}")
         return True
 
     def _build_cotp_cc(self) -> bytes:
-        """Build COTP Connection Confirm."""
-        # Basic COTP CC
+        """Build COTP Connection Confirm.
+
+        Includes the TPDU size parameter (0xC0) so clients know the
+        negotiated maximum segment size and don't fall back to the
+        ISO 8073 class-0 default of 128 bytes.
+        """
+        pdu_size_param = struct.pack(">BBB", self.COTP_PARAM_PDU_SIZE, 1, self.tpdu_size)
+        pdu_length = 6 + len(pdu_size_param)
         base_pdu = struct.pack(
-            ">BBHHB",
-            6,  # PDU length
+            ">BBBHHB",
+            pdu_length,  # PDU length
             self.COTP_CC,  # PDU type
+            0x00,  # Reserved / CDT
             self.dst_ref,  # Destination reference (client's source ref)
             self.src_ref,  # Source reference (our ref)
             0x00,  # Class/option
         )
 
-        return struct.pack(">B", 6) + base_pdu[1:]
+        return base_pdu + pdu_size_param
 
     def _recv_exact(self, size: int) -> bytes:
         """Receive exactly the specified number of bytes."""
@@ -2617,18 +2659,6 @@ class ServerISOConnection:
         header = struct.pack(">BBB", 2, self.COTP_DT, 0x80)
         return header + data
 
-    def _parse_cotp_data(self, cotp_pdu: bytes) -> bytes:
-        """Parse COTP Data Transfer PDU and extract S7 data."""
-        if len(cotp_pdu) < 3:
-            raise S7ConnectionError("Invalid COTP DT: too short")
-
-        pdu_len, pdu_type, eot_num = struct.unpack(">BBB", cotp_pdu[:3])
-
-        if pdu_type != self.COTP_DT:
-            raise S7ConnectionError(f"Expected COTP DT, got {pdu_type:#02x}")
-
-        return cotp_pdu[3:]  # Return data portion
-
 
 def mainloop(tcp_port: int = 1102, init_standard_values: bool = False) -> None:
     """

{python_snap7-3.1.0 → python_snap7-3.1.1}/snap7/util/getters.py

@@ -149,17 +149,22 @@ def get_real(bytearray_: Buffer, byte_index: int) -> float:
     return real
 
 
-def get_fstring(bytearray_: Buffer, byte_index: int, max_length: int, remove_padding: bool = True) -> str:
+def get_fstring(
+    bytearray_: Buffer, byte_index: int, max_length: int, remove_padding: bool = True, encoding: str = "latin-1"
+) -> str:
     """Parse space-padded fixed-length string from bytearray
 
     Notes:
-        This function supports fixed-length ASCII strings, right-padded with spaces.
+        This function supports fixed-length strings, right-padded with spaces.
+        Use the ``encoding`` parameter to decode multi-byte strings (e.g. ``"gbk"``
+        for Chinese PLCs or ``"utf-8"``).
 
     Args:
         bytearray_: buffer from where to get the string.
         byte_index: byte index from where to start reading.
-        max_length: the maximum length of the string.
+        max_length: the maximum length of the string in bytes.
         remove_padding: whether to remove the right-padding.
+        encoding: character encoding used to decode the raw bytes (default ``"latin-1"``).
 
     Returns:
         String value.
@@ -171,8 +176,8 @@ def get_fstring(bytearray_: Buffer, byte_index: int, max_length: int, remove_pad
         >>> get_fstring(data, 0, 15, remove_padding=False)
         'hello world    '
     """
-    data = map(chr, bytearray_[byte_index : byte_index + max_length])
-    string = "".join(data)
+    raw = bytes(bytearray_[byte_index : byte_index + max_length])
+    string = raw.decode(encoding)
 
     if remove_padding:
         return string.rstrip(" ")
@@ -180,16 +185,19 @@ def get_fstring(bytearray_: Buffer, byte_index: int, max_length: int, remove_pad
         return string
 
 
-def get_string(bytearray_: Buffer, byte_index: int) -> str:
+def get_string(bytearray_: Buffer, byte_index: int, encoding: str = "latin-1") -> str:
     """Parse string from bytearray
 
     Notes:
         The first byte of the buffer will contain the max size posible for a string.
         The second byte contains the length of the string that contains.
+        Use the ``encoding`` parameter to decode multi-byte strings (e.g. ``"gbk"``
+        for Chinese PLCs or ``"utf-8"``).
 
     Args:
         bytearray_: buffer from where to get the string.
         byte_index: byte index from where to start reading.
+        encoding: character encoding used to decode the raw bytes (default ``"latin-1"``).
 
     Returns:
         String value.
@@ -210,8 +218,8 @@ def get_string(bytearray_: Buffer, byte_index: int) -> str:
             "String contains {str_length} chars, but max. {max_string_size} chars are expected or is "
             "larger than 254. Bytearray doesn't seem to be a valid string."
         )
-    data = map(chr, bytearray_[byte_index + 2 : byte_index + 2 + str_length])
-    return "".join(data)
+    raw = bytes(bytearray_[byte_index + 2 : byte_index + 2 + str_length])
+    return raw.decode(encoding)
 
 
 def get_dword(bytearray_: Buffer, byte_index: int) -> int:

{python_snap7-3.1.0 → python_snap7-3.1.1}/snap7/util/setters.py

@@ -159,19 +159,20 @@ def set_real(bytearray_: Buffer, byte_index: int, real: Union[bool, str, float,
     return bytearray_
 
 
-def set_fstring(bytearray_: Buffer, byte_index: int, value: str, max_length: int) -> Buffer:
+def set_fstring(bytearray_: Buffer, byte_index: int, value: str, max_length: int, encoding: str = "latin-1") -> Buffer:
     """Set space-padded fixed-length string value
 
     Args:
         bytearray_: buffer to write to.
         byte_index: byte index to start writing from.
         value: string to write.
-        max_length: maximum string length, i.e. the fixed size of the string.
+        max_length: maximum string length in bytes, i.e. the fixed size of the string.
+        encoding: character encoding used to encode the string (default ``"latin-1"``).
 
     Raises:
         :obj:`TypeError`: if the `value` is not a :obj:`str`.
-        :obj:`ValueError`: if the length of the `value` is larger than the
-            ``max_size`` or ``value`` contains non-ASCII characters.
+        :obj:`ValueError`: if the encoded byte length of the `value` is larger than
+            ``max_length``.
 
     Examples:
         >>> data = bytearray(20)
@@ -179,38 +180,34 @@ def set_fstring(bytearray_: Buffer, byte_index: int, value: str, max_length: int
         >>> data
             bytearray(b'hello world    \x00\x00\x00\x00\x00')
     """
-    if not value.isascii():
-        raise ValueError("Value contains non-ascii values.")
-    # FAIL HARD WHEN trying to write too much data into PLC
-    size = len(value)
+    encoded = value.encode(encoding)
+    size = len(encoded)
     if size > max_length:
-        raise ValueError(f"size {size} > max_length {max_length} {value}")
+        raise ValueError(f"encoded byte size {size} > max_length {max_length} {value}")
 
-    # fill array with chr integers
-    for i, c in enumerate(value):
-        bytearray_[byte_index + i] = ord(c)
+    bytearray_[byte_index : byte_index + size] = encoded
 
-    # fill the rest with empty space
-    for r in range(len(value), max_length):
+    # fill the rest with spaces
+    for r in range(size, max_length):
         bytearray_[byte_index + r] = ord(" ")
 
     return bytearray_
 
 
-def set_string(bytearray_: Buffer, byte_index: int, value: str, max_size: int = 254) -> Buffer:
+def set_string(bytearray_: Buffer, byte_index: int, value: str, max_size: int = 254, encoding: str = "latin-1") -> Buffer:
     """Set string value
 
     Args:
         bytearray_: buffer to write to.
         byte_index: byte index to start writing from.
         value: string to write.
-        max_size: maximum possible string size, max. 254 as default.
+        max_size: maximum possible string size in bytes, max. 254 as default.
+        encoding: character encoding used to encode the string (default ``"latin-1"``).
 
     Raises:
         :obj:`TypeError`: if the `value` is not a :obj:`str`.
-        :obj:`ValueError`: if the length of the `value` is larger than the
-            ``max_size``, or ``max_size`` is greater than 254, or ``value``
-            contains characters with ordinal > 255.
+        :obj:`ValueError`: if the encoded byte length of the `value` is larger than the
+            ``max_size``, or ``max_size`` is greater than 254.
 
     Examples:
         >>> from snap7.util import set_string
@@ -225,29 +222,21 @@ def set_string(bytearray_: Buffer, byte_index: int, value: str, max_size: int =
     if max_size > 254:
         raise ValueError(f"max_size: {max_size} > max. allowed 254 chars")
 
-    if any(ord(char) < 0 or ord(char) > 255 for char in value):
-        raise ValueError(
-            "Value contains ascii values > 255, which is not compatible with PLC Type STRING. "
-            "Check encoding of value or try set_wstring()."
-        )
-
-    size = len(value)
-    # FAIL HARD WHEN trying to write too much data into PLC
+    encoded = value.encode(encoding)
+    size = len(encoded)
     if size > max_size:
-        raise ValueError(f"size {size} > max_size {max_size} {value}")
+        raise ValueError(f"encoded byte size {size} > max_size {max_size} {value}")
 
     # set max string size
     bytearray_[byte_index] = max_size
 
-    # set len count on first position
-    bytearray_[byte_index + 1] = len(value)
+    # set actual byte length
+    bytearray_[byte_index + 1] = size
 
-    # fill array with chr integers
-    for i, c in enumerate(value):
-        bytearray_[byte_index + 2 + i] = ord(c)
+    bytearray_[byte_index + 2 : byte_index + 2 + size] = encoded
 
-    # fill the rest with empty space
-    for r in range(len(value), bytearray_[byte_index]):
+    # fill the rest with spaces
+    for r in range(size, bytearray_[byte_index]):
         bytearray_[byte_index + 2 + r] = ord(" ")
 
     return bytearray_

{python_snap7-3.1.0 → python_snap7-3.1.1}/tests/test_reconnect.py

@@ -10,7 +10,8 @@ import pytest
 from snap7.client import Client
 from snap7.error import S7ConnectionError
 from snap7.server import Server
-from snap7.type import SrvArea
+from snap7.tags import Tag
+from snap7.type import Area, SrvArea
 
 logging.basicConfig(level=logging.WARNING)
 
@@ -152,6 +153,26 @@ class TestAutoReconnect(unittest.TestCase):
         finally:
             client.disconnect()
 
+    def test_reconnect_on_multi_block_read(self) -> None:
+        """Client reconnects when connection drops during multi-block sequential read."""
+        client = Client(auto_reconnect=True, max_retries=3, retry_delay=0.1)
+        client.connect(ip, rack, slot, tcpport)
+
+        try:
+            tags = [Tag(Area.DB, db_number, i * 2, "INT") for i in range(20)]
+            data = client.read_tags(tags)
+            assert len(data) == 20
+
+            if client.connection and client.connection.socket:
+                client.connection.socket.close()
+            client.connected = False
+
+            data = client.read_tags(tags)
+            assert len(data) == 20
+            assert client.connected is True
+        finally:
+            client.disconnect()
+
     def test_no_reconnect_when_disabled(self) -> None:
         """Without auto_reconnect, connection errors propagate immediately."""
         client = Client(auto_reconnect=False)