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

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

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: python-snap7
-Version: 3.1.0
+Version: 3.1.2
 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.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-snap7"
-version = "3.1.0"
+version = "3.1.2"
 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.2/python_snap7.egg-info}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: python-snap7
-Version: 3.1.0
+Version: 3.1.2
 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.2}/snap7/async_client.py

@@ -239,9 +239,17 @@ class AsyncISOTCPConnection:
             param_data = data[offset + 2 : offset + 2 + param_len]
             if param_code == self.COTP_PARAM_PDU_SIZE:
                 if param_len == 1:
-                    self.pdu_size = 1 << param_data[0]
+                    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:
-                    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}")
             offset += 2 + param_len
 
@@ -389,7 +397,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 +1167,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.2}/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.2}/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.2}/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}")