python-snap7 3.1.1__py3-none-any.whl → 3.2.0__py3-none-any.whl

python_snap7-3.2.0.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: python-snap7
+Version: 3.2.0
+Summary: Pure Python S7 communication library for Siemens PLCs
+Author-email: Gijs Molenaar <gijsmolenaar@gmail.com>
+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
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Topic :: System :: Hardware
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Manufacturing
+Classifier: Operating System :: POSIX
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-html; extra == "test"
+Requires-Dist: hypothesis; extra == "test"
+Requires-Dist: mypy; extra == "test"
+Requires-Dist: types-setuptools; extra == "test"
+Requires-Dist: ruff; extra == "test"
+Requires-Dist: tox; extra == "test"
+Requires-Dist: tox-uv; extra == "test"
+Requires-Dist: types-click; extra == "test"
+Requires-Dist: uv; extra == "test"
+Provides-Extra: cli
+Requires-Dist: rich; extra == "cli"
+Requires-Dist: click; extra == "cli"
+Provides-Extra: demo
+Requires-Dist: psutil; extra == "demo"
+Requires-Dist: rich; extra == "demo"
+Requires-Dist: click; extra == "demo"
+Provides-Extra: doc
+Requires-Dist: sphinx; extra == "doc"
+Requires-Dist: sphinx_rtd_theme; extra == "doc"
+Provides-Extra: discovery
+Requires-Dist: pnio-dcp; extra == "discovery"
+Provides-Extra: ppi
+Requires-Dist: pyserial>=3.5; extra == "ppi"
+Dynamic: license-file
+
+.. image:: https://img.shields.io/pypi/v/python-snap7.svg
+   :target: https://pypi.org/project/python-snap7/
+
+.. image:: https://img.shields.io/pypi/pyversions/python-snap7.svg
+   :target: https://pypi.org/project/python-snap7/
+
+.. image:: https://img.shields.io/github/license/gijzelaerr/python-snap7.svg
+   :target: https://github.com/gijzelaerr/python-snap7/blob/master/LICENSE
+
+.. image:: https://github.com/gijzelaerr/python-snap7/actions/workflows/test.yml/badge.svg
+   :target: https://github.com/gijzelaerr/python-snap7/actions/workflows/test.yml
+
+.. image:: https://readthedocs.org/projects/python-snap7/badge/
+   :target: https://python-snap7.readthedocs.io/en/latest/
+
+
+python-snap7
+============
+
+python-snap7 is a pure-Python library for communicating with Siemens S7 PLCs
+using the classic S7 protocol. It supports S7-300 and S7-400 controllers, as
+well as S7-1200 and S7-1500 controllers with PUT/GET access enabled. It
+supports Python 3.10+ on Windows, Linux, and macOS without native dependencies.
+
+Installation
+============
+
+Install from PyPI::
+
+   pip install python-snap7
+
+Quick start
+===========
+
+::
+
+   from s7 import Client
+
+   client = Client()
+   client.connect("192.168.1.10", 0, 1)
+   data = client.db_read(1, 0, 4)
+   client.disconnect()
+
+The ``s7`` package is the recommended import. The ``snap7`` package name is
+also available for backwards compatibility.
+
+Documentation
+=============
+
+Read the full documentation at
+`python-snap7.readthedocs.io <https://python-snap7.readthedocs.io/en/latest/>`_.

python_snap7-3.2.0.dist-info/RECORD

@@ -0,0 +1,34 @@
+python_snap7-3.2.0.dist-info/licenses/LICENSE,sha256=PIihE_yP-8gc-ff9ikvQQPOa0biOCZ6Bc-6h3G3xRUQ,1097
+s7/__init__.py,sha256=q6E4rA1BDx36PPkJS55xv7XCxwlaQeEK6HNotFjLeYo,1096
+snap7/__init__.py,sha256=2NAAE1oaSSd7DqPl0dx7jNXtsM2PRBWRm9X-bkmgC6U,1275
+snap7/async_client.py,sha256=epBMT21GN_VbjL1jwoPiC0fYOdsO7NzaEKZw62DKNnM,50279
+snap7/cli.py,sha256=L1B7NMAemDcl93JUSqJV3Ls_CN2ghlG75nTMD08JkMs,13787
+snap7/client.py,sha256=pXe2A8C0X6uBxg4ya6lXK4JpRhADtOxlfuJXyIod-bg,106424
+snap7/client_base.py,sha256=J6_PheEZb93_UE9fPKQaI2RRofF0P3o71EFcBySDW3s,8568
+snap7/connection.py,sha256=Qjis-ICK6E74_YfoJuy2_lgDqfSYs4ULux1FShJVvtw,18834
+snap7/datatypes.py,sha256=Gqu1XDuKkQI76n4TYrFrhm0RlPz4XNA5GKA-GJJXJDU,12042
+snap7/demo.py,sha256=JWSKLj2QPIXeSFTZSXuADAJzWVKls712MUZnuqwNkNs,17376
+snap7/discovery.py,sha256=LONPYg83b2quKXht6y_GTTArdxitjD8DoGyaHfe9B1w,3964
+snap7/error.py,sha256=S5BquFFSL1NpgdytIpOD_FzhN6gOCngSkxJVZT4rxdw,21323
+snap7/log.py,sha256=XX4UyPgByz3EhTc39BTGY454fHvYmiJAX4v-a-gkIEY,4968
+snap7/logo.py,sha256=0h-EZ5K86Qddna_lryBn6xLXLVwnznYJuMGuevzH6bI,9192
+snap7/optimizer.py,sha256=Bu4zWCfdeA5GG3sWwjYOLkp0tWEfNbAXvbe_RldlYVM,9383
+snap7/partner.py,sha256=HxaTYfojsf5Z170R4cAYFzoMSwqCOF42qPCkOaxbUkU,37916
+snap7/ppi.py,sha256=p0fVelfUQOT3QH5uuWOjpDxA5IyT3gx5FzCMaYYEuWQ,16070
+snap7/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+snap7/rate_limiter.py,sha256=dnXCOJLWmszo8oskbFM0om0gPC4LHHCOr-Nt22tImeU,4151
+snap7/s7protocol.py,sha256=xQrCTzC2xEe8ykfa3T2-kR9sLFDP8M7GZMfsm-n2i34,64835
+snap7/szl.py,sha256=a9NhH7Lyp8SXJ2_kvyyV-14srIxm3tXnAnclBy5alDk,7998
+snap7/tags.py,sha256=TmbNRHNWZVe3Yl_1L5WXE3Qb0lxIEW-veoCRGt0giZQ,26987
+snap7/type.py,sha256=EiXqU0ayYYxlM-5fUcPL7psgL1EGNNqAa7JXH4QlAnU,9752
+snap7/server/__init__.py,sha256=MOX_0oeC5pBoKEN_4V5XPnaU9ONQM_uELoDfdjlDeQg,112740
+snap7/server/__main__.py,sha256=OdOgyMmFThjSe2jSgvlbkquGYnZcBW6wubs2ldhNSOE,1206
+snap7/util/__init__.py,sha256=d6n2oy7tNYke1ia0TUyWz_ni3l0XN1qvilM5sW0T-Es,1874
+snap7/util/db.py,sha256=geesYS2oyOuTADOJa2me1p1rqJVzPuLTCfye6JIeav0,27120
+snap7/util/getters.py,sha256=nKRfLC2yClfoLxd4MKq1SuBPhzVP1RpV9hwxxWlavug,25391
+snap7/util/setters.py,sha256=BpFqVxxUbhqarV6Gzt4ZuxycHljtDYsONCr6e9G33Ms,27226
+python_snap7-3.2.0.dist-info/METADATA,sha256=bII7Hr47W-S5gb3lW4I6vJd88XP1sba4R339occZajI,3502
+python_snap7-3.2.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+python_snap7-3.2.0.dist-info/entry_points.txt,sha256=IPZyYr1lKyavXXpAc4xO505afTGwTY8GmNFuy5lsSiM,75
+python_snap7-3.2.0.dist-info/top_level.txt,sha256=PTgDoDG45QNL2XIE9RM7S_ZCdWQjtMMuXNyrI2UdnbU,9
+python_snap7-3.2.0.dist-info/RECORD,,

{python_snap7-3.1.1.dist-info → python_snap7-3.2.0.dist-info}/top_level.txt

@@ -1 +1,2 @@
+s7
 snap7

s7/__init__.py

@@ -0,0 +1,52 @@
+"""Alias for the ``snap7`` package.
+
+``s7`` re-exports everything from ``snap7`` so that either name works::
+
+    from s7 import Client          # same as: from snap7 import Client
+    from s7.type import Area       # same as: from snap7.type import Area
+
+Both import names are supported; ``s7`` is recommended for new code.
+"""
+
+import importlib
+import sys
+
+import snap7 as snap7  # noqa: F401
+
+from snap7 import *  # noqa: F403
+from snap7 import __all__ as __all__, __version__ as __version__
+
+_SUBMODULES = [
+    "async_client",
+    "cli",
+    "client",
+    "client_base",
+    "connection",
+    "datatypes",
+    "demo",
+    "discovery",
+    "error",
+    "log",
+    "logo",
+    "optimizer",
+    "partner",
+    "ppi",
+    "rate_limiter",
+    "s7protocol",
+    "server",
+    "szl",
+    "tags",
+    "type",
+    "util",
+]
+
+for _name in _SUBMODULES:
+    _fqn = f"s7.{_name}"
+    if _fqn not in sys.modules:
+        try:
+            _mod = importlib.import_module(f"snap7.{_name}")
+            sys.modules[_fqn] = _mod
+        except ImportError:
+            pass
+
+del _name, _fqn, _mod, _SUBMODULES

snap7/__init__.py

@@ -1,8 +1,15 @@
 """
-The Snap7 Python library.
+The snap7 compatibility package.
 
-Pure Python implementation of the S7 protocol for communicating with
-Siemens S7 PLCs without requiring the native Snap7 C library.
+Pure Python implementation of the classic S7 protocol for communicating with
+Siemens S7 PLCs. This package is kept for backwards compatibility. For new
+projects, use the ``s7`` package instead::
+
+    from s7 import Client
+
+    client = Client()
+    client.connect("192.168.1.10", 0, 1)
+    data = client.db_read(1, 0, 4)
 """
 
 from importlib.metadata import version, PackageNotFoundError
@@ -11,16 +18,19 @@ from .client import Client
 from .async_client import AsyncClient
 from .server import Server
 from .partner import Partner
+from .ppi import PPIArea, PPIClient
 from .logo import Logo
 from .util.db import Row, DB
 from .tags import NodeS7Tag, PLC4XTag, Tag, from_browse, load_csv, load_json, load_tia_xml, parse_tag
-from .type import Area, Block, WordLen, SrvEvent, SrvArea
+from .type import Area, Block, ForceEntry, WordLen, SrvEvent, SrvArea
 
 __all__ = [
     "Client",
     "AsyncClient",
     "Server",
     "Partner",
+    "PPIClient",
+    "PPIArea",
     "Logo",
     "Row",
     "DB",
@@ -34,6 +44,7 @@ __all__ = [
     "from_browse",
     "Area",
     "Block",
+    "ForceEntry",
     "WordLen",
     "SrvEvent",
     "SrvArea",

snap7/async_client.py

@@ -1,8 +1,9 @@
-"""
-Native async S7 client implementation.
+"""Asynchronous client for the classic S7 protocol.
 
 Uses asyncio streams for non-blocking I/O with an asyncio.Lock() to serialize
 send/receive cycles, ensuring safe concurrent use via asyncio.gather().
+
+``s7.AsyncClient`` and ``snap7.AsyncClient`` expose this same implementation.
 """
 
 import asyncio
@@ -15,14 +16,17 @@ from datetime import datetime
 
 from .connection import TPDUSize
 from .s7protocol import S7Protocol, get_return_code_description
-from .datatypes import S7WordLen
+from .datatypes import S7DataTypes, S7WordLen
 from .error import S7Error, S7ConnectionError, S7ProtocolError, S7TimeoutError
 from .client_base import ClientMixin
 from .szl import parse_cp_info_szl, parse_cpu_info_szl, parse_order_code_szl, parse_protection_szl
+from .client import _parse_force_szl
+from .rate_limiter import RateLimitAlgorithm, RateLimitBehavior, RequestRateLimiter
 from .type import (
     Area,
     Block,
     BlocksList,
+    ForceEntry,
     S7CpuInfo,
     TS7BlockInfo,
     S7CpInfo,
@@ -156,7 +160,7 @@ class AsyncISOTCPConnection:
                 raise S7ConnectionError(f"Invalid TPKT version: {version}")
 
             remaining = length - 4
-            if remaining <= 0:
+            if length < 7:
                 raise S7ConnectionError("Invalid TPKT length")
 
             payload = await self._recv_exact(remaining)
@@ -165,6 +169,10 @@ class AsyncISOTCPConnection:
             if len(payload) < 3:
                 raise S7ConnectionError("Invalid COTP DT: too short")
             pdu_len, pdu_type, eot_num = struct.unpack(">BBB", payload[:3])
+            if pdu_len != 2:
+                raise S7ConnectionError("Invalid COTP DT header length")
+            if eot_num & 0x7F:
+                raise S7ConnectionError("Invalid Class 0 COTP TPDU number")
             if pdu_type != self.COTP_DT:
                 raise S7ConnectionError(f"Expected COTP DT, got {pdu_type:#02x}")
             return payload[3:]
@@ -214,6 +222,8 @@ class AsyncISOTCPConnection:
     def _build_tpkt(self, payload: bytes) -> bytes:
         """Build TPKT frame."""
         length = len(payload) + 4
+        if not 7 <= length <= 65535:
+            raise S7ConnectionError("Invalid TPKT length: expected 7..65535 bytes")
         return struct.pack(">BBH", 3, 0, length) + payload
 
     def _parse_cotp_cc(self, data: bytes) -> None:
@@ -239,9 +249,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
 
@@ -277,23 +295,31 @@ class AsyncISOTCPConnection:
 
 
 class AsyncClient(ClientMixin):
-    """
-    Native async S7 client implementation.
+    """Asynchronous client for classic S7 communication.
 
     Uses asyncio streams for non-blocking I/O. An internal asyncio.Lock
     serializes each send+receive cycle so that concurrent coroutines
     (e.g. via asyncio.gather) never interleave on the same TCP socket.
 
+    For new projects, use ``s7.AsyncClient`` instead.
+
     Examples:
-        >>> import snap7
-        >>> async with snap7.AsyncClient() as client:
+        >>> from s7 import AsyncClient
+        >>> async with AsyncClient() as client:
         ...     await client.connect("192.168.1.10", 0, 1)
         ...     data = await client.db_read(1, 0, 4)
     """
 
     MAX_VARS = 20
 
-    def __init__(self) -> None:
+    def __init__(
+        self,
+        *,
+        max_requests_per_second: float = 0,
+        rate_limit_algorithm: RateLimitAlgorithm = "fixed",
+        rate_limit_behavior: RateLimitBehavior = "block",
+        rate_limit_burst: int | None = None,
+    ) -> None:
         self.connection: Optional[AsyncISOTCPConnection] = None
         self.protocol = S7Protocol()
         self.connected = False
@@ -312,6 +338,12 @@ class AsyncClient(ClientMixin):
         self._last_error = 0
 
         self._lock = asyncio.Lock()
+        self._rate_limiter = RequestRateLimiter(
+            max_requests_per_second,
+            algorithm=rate_limit_algorithm,
+            behavior=rate_limit_behavior,
+            burst_capacity=rate_limit_burst,
+        )
 
         self._params = {
             Parameter.RemotePort: 102,
@@ -331,6 +363,11 @@ class AsyncClient(ClientMixin):
             raise S7ConnectionError("Not connected to PLC")
         return self.connection
 
+    async def _send_data(self, conn: AsyncISOTCPConnection, request: bytes) -> None:
+        """Apply the per-client rate limit and send one S7 request PDU."""
+        await self._rate_limiter.acquire_async()
+        await conn.send_data(request)
+
     async def _send_receive(self, request: bytes, max_stale_retries: int = 3) -> dict[str, Any]:
         """Send a request and receive/parse the response, holding the lock.
 
@@ -350,7 +387,7 @@ class AsyncClient(ClientMixin):
         expected_seq = struct.unpack(">H", request[4:6])[0]
 
         async with self._lock:
-            await conn.send_data(request)
+            await self._send_data(conn, request)
 
             for attempt in range(max_stale_retries + 1):
                 response_data = await conn.receive_data()
@@ -517,7 +554,7 @@ class AsyncClient(ClientMixin):
         else:
             word_len = S7WordLen.BYTE
 
-        max_chunk = self._max_read_size()
+        max_chunk = self._read_chunk_count(word_len)
         if size <= max_chunk:
             request = self.protocol.build_read_request(
                 area=s7_area, db_number=db_number, start=start, word_len=word_len, count=size
@@ -533,7 +570,11 @@ class AsyncClient(ClientMixin):
         while remaining > 0:
             chunk_size = min(remaining, max_chunk)
             request = self.protocol.build_read_request(
-                area=s7_area, db_number=db_number, start=start + offset, word_len=word_len, count=chunk_size
+                area=s7_area,
+                db_number=db_number,
+                start=start + offset * self._element_address_step(word_len),
+                word_len=word_len,
+                count=chunk_size,
             )
             response = await self._send_receive(request)
             values = self.protocol.extract_read_data(response, word_len, chunk_size)
@@ -559,7 +600,7 @@ class AsyncClient(ClientMixin):
         else:
             word_len = S7WordLen.BYTE
 
-        max_chunk = self._max_write_size()
+        max_chunk = self._write_chunk_bytes(word_len, len(data))
         if len(data) <= max_chunk:
             request = self.protocol.build_write_request(
                 area=s7_area, db_number=db_number, start=start, word_len=word_len, data=bytes(data)
@@ -575,7 +616,11 @@ class AsyncClient(ClientMixin):
             chunk_size = min(remaining, max_chunk)
             chunk_data = data[offset : offset + chunk_size]
             request = self.protocol.build_write_request(
-                area=s7_area, db_number=db_number, start=start + offset, word_len=word_len, data=bytes(chunk_data)
+                area=s7_area,
+                db_number=db_number,
+                start=start + offset // S7DataTypes.get_size_bytes(word_len) * self._element_address_step(word_len),
+                word_len=word_len,
+                data=bytes(chunk_data),
             )
             response = await self._send_receive(request)
             self.protocol.check_write_response(response)
@@ -695,7 +740,7 @@ class AsyncClient(ClientMixin):
 
             async with self._lock:
                 followup = self.protocol.build_userdata_followup_request(group, subfunction, sequence_number)
-                await conn.send_data(followup)
+                await self._send_data(conn, followup)
                 response_data = await conn.receive_data()
 
             response = self.protocol.parse_response(response_data)
@@ -819,7 +864,7 @@ class AsyncClient(ClientMixin):
         )
 
         async with self._lock:
-            await conn.send_data(header + param_data + data_section)
+            await self._send_data(conn, header + param_data + data_section)
             response_data = await conn.receive_data()
         self.protocol.parse_response(response_data)
 
@@ -836,7 +881,7 @@ class AsyncClient(ClientMixin):
         )
 
         async with self._lock:
-            await conn.send_data(header + param_data)
+            await self._send_data(conn, header + param_data)
             response_data = await conn.receive_data()
         self.protocol.parse_response(response_data)
 
@@ -1009,7 +1054,7 @@ class AsyncClient(ClientMixin):
 
             async with self._lock:
                 followup = self.protocol.build_userdata_followup_request(group, subfunction, sequence_number)
-                await conn.send_data(followup)
+                await self._send_data(conn, followup)
                 response_data = await conn.receive_data()
 
             response = self.protocol.parse_response(response_data)
@@ -1065,6 +1110,109 @@ class AsyncClient(ClientMixin):
             raise S7ConnectionError("Not connected to PLC")
         return parse_protection_szl(await self.read_szl(0x0232, 0))
 
+    # ---------------------------------------------------------------
+    # Force I/O
+    # ---------------------------------------------------------------
+
+    _FORCE_AREAS: frozenset[int] = frozenset({Area.PE, Area.PA})
+
+    async def force_bit(self, area: Area, byte_offset: int, bit: int, value: bool) -> None:
+        """Force a single I/O bit in the process image.
+
+        Async equivalent of :meth:`snap7.client.Client.force_bit`.
+        """
+        if area not in self._FORCE_AREAS:
+            raise ValueError(f"Force is only supported for PE (inputs) and PA (outputs), got {area!r}")
+        if not 0 <= bit <= 7:
+            raise ValueError(f"Bit must be 0-7, got {bit}")
+
+        current = await self.read_area(area, 0, byte_offset, 1)
+        if value:
+            current[0] |= 1 << bit
+        else:
+            current[0] &= ~(1 << bit)
+        await self.write_area(area, 0, byte_offset, current)
+        logger.info(f"Forced {area.name} byte {byte_offset} bit {bit} = {value}")
+
+    async def cancel_force(self, area: Area, byte_offset: int, bit: int) -> None:
+        """Cancel a forced I/O bit by clearing it in the process image.
+
+        Async equivalent of :meth:`snap7.client.Client.cancel_force`.
+        """
+        if area not in self._FORCE_AREAS:
+            raise ValueError(f"Cancel force is only supported for PE (inputs) and PA (outputs), got {area!r}")
+        if not 0 <= bit <= 7:
+            raise ValueError(f"Bit must be 0-7, got {bit}")
+
+        current = await self.read_area(area, 0, byte_offset, 1)
+        current[0] &= ~(1 << bit)
+        await self.write_area(area, 0, byte_offset, current)
+        logger.info(f"Cancelled force on {area.name} byte {byte_offset} bit {bit}")
+
+    async def read_force_table(self) -> list[ForceEntry]:
+        """Read the PLC force table via SZL 0x0025.
+
+        Async equivalent of :meth:`snap7.client.Client.read_force_table`.
+        """
+        if not self.get_connected():
+            raise S7ConnectionError("Not connected to PLC")
+
+        try:
+            szl = await self.read_szl(0x0025, 0x0000)
+        except (S7ProtocolError, RuntimeError):
+            logger.debug("SZL 0x0025 not available; returning empty force table")
+            return []
+
+        raw = bytes(szl.Data[: szl.Header.LengthDR])
+        return _parse_force_szl(raw)
+
+    async def set_session_password(self, password: str) -> int:
+        """Set the session password to unlock a password-protected PLC.
+
+        Sends an S7 USERDATA request (function group 5, subfunction 1)
+        with the encoded password.
+
+        Args:
+            password: Plaintext password (max 8 ASCII characters).
+
+        Returns:
+            0 on success.
+
+        Raises:
+            ~snap7.error.S7ConnectionError: If not connected.
+            ~snap7.error.S7ProtocolError: If the PLC rejects the password.
+        """
+        if not self.get_connected():
+            raise S7ConnectionError("Not connected to PLC")
+
+        encoded = self.protocol.encode_password(password)
+        request = self.protocol.build_set_session_password_request(encoded)
+        response = await self._send_receive(request)
+        self.protocol.check_userdata_response(response)
+        logger.info("Session password set successfully")
+        return 0
+
+    async def clear_session_password(self) -> int:
+        """Clear the session password, returning to the default protection level.
+
+        Sends an S7 USERDATA request (function group 5, subfunction 2).
+
+        Returns:
+            0 on success.
+
+        Raises:
+            ~snap7.error.S7ConnectionError: If not connected.
+            ~snap7.error.S7ProtocolError: If the PLC rejects the request.
+        """
+        if not self.get_connected():
+            raise S7ConnectionError("Not connected to PLC")
+
+        request = self.protocol.build_clear_session_password_request()
+        response = await self._send_receive(request)
+        self.protocol.check_userdata_response(response)
+        logger.info("Session password cleared successfully")
+        return 0
+
     async def compress(self, timeout: int) -> int:
         """Compress PLC memory."""
         if not self.get_connected():
@@ -1092,7 +1240,7 @@ class AsyncClient(ClientMixin):
         conn = self._get_connection()
 
         async with self._lock:
-            await conn.send_data(bytes(data))
+            await self._send_data(conn, bytes(data))
             response = await conn.receive_data()
         return bytearray(response)
 

snap7/cli.py

@@ -15,9 +15,8 @@ from typing import Optional
 
 try:
     import click
-except ImportError:
-    print("CLI dependencies not installed. Try: pip install python-snap7[cli]")
-    raise
+except ImportError as exc:
+    raise ImportError("CLI dependencies not installed. Install them with: pip install python-snap7[cli]") from exc
 
 from snap7 import __version__
 from snap7.client import Client